def get(self, session, requires_id=True, error_message=None):
stk = super(Stack, self).get(session, requires_id=requires_id,
error_message=error_message)
if stk and stk.status in ['DELETE_COMPLETE', 'ADOPT_COMPLETE']:
raise exceptions.NotFoundException(
"No stack found for %s" % stk.id)
return stk
def test_wait_for_delete(self):
sess = mock.Mock()
sot = FakeResource.new(**fake_data)
sot.get = mock.MagicMock()
sot.get.side_effect = [sot, exceptions.NotFoundException(mock.Mock())]
self.assertEqual(sot, resource.wait_for_delete(sess, sot, 1, 2))
def test_not_found_in_cache_active_introspection(self, mock_record):
CONF.set_override('permit_active_introspection', True, 'processing')
self.find_mock.side_effect = utils.NotFoundInCacheError('not found')
self.cli.get_node.side_effect = os_exc.NotFoundException('boom')
self.cache_fixture.mock.acquire_lock = mock.Mock()
self.cache_fixture.mock.uuid = '1111'
self.cache_fixture.mock.finished_at = None
self.cache_fixture.mock.node = mock.Mock()
mock_record.return_value = self.cache_fixture.mock
res = process.process(self.data)
self.assertEqual(self.fake_result_json, res)
self.find_mock.assert_called_once_with(
bmc_address=[self.bmc_address, self.bmc_v6address], mac=mock.ANY)
actual_macs = self.find_mock.call_args[1]['mac']
self.assertEqual(sorted(self.all_macs), sorted(actual_macs))
mock_record.assert_called_once_with(bmc_addresses=[
'1.2.3.4', '2001:1234:1234:1234:1234:1234:1234:1234/64'
],
macs=mock.ANY)
actual_macs = mock_record.call_args[1]['macs']
self.assertEqual(sorted(self.all_macs), sorted(actual_macs))
self.cli.get_node.assert_not_called()
self.process_mock.assert_called_once_with(mock.ANY, mock.ANY,
self.data)
def test_get_not_found(self):
self.res.get.side_effect = exceptions.NotFoundException(
message="test", http_status=404)
# TODO(shade) The mock here does not mock the right things, so we're
# not testing the actual exception mechanism.
self.assertRaisesRegex(exceptions.NotFoundException, "test",
self.sot._get, RetrieveableResource, self.res)
def test_is_not_found(self):
self.assertFalse(
self.plugin.is_not_found(
exceptions.HttpException(http_status=400)))
self.assertFalse(self.plugin.is_not_found(Exception))
self.assertTrue(
self.plugin.is_not_found(
exceptions.NotFoundException(http_status=404)))
def test_get_not_found(self):
self.res.get.side_effect = exceptions.NotFoundException(
message="test", http_status=404)
self.assertRaisesRegexp(
exceptions.ResourceNotFound,
"No %s found for %s" % (RetrieveableResource.__name__, self.res),
self.sot._get, RetrieveableResource, self.res)
def test_delete_ResourceNotFound(self):
self.res.delete.side_effect = exceptions.NotFoundException(
message="test", status_code=404)
self.assertRaisesRegexp(
exceptions.ResourceNotFound,
"No %s found for %s" % (DeleteableResource.__name__, self.res),
self.sot._delete, DeleteableResource, self.res,
ignore_missing=False)
def test_not_found_in_ironic(self):
self.cli.get_node.side_effect = os_exc.NotFoundException()
self.assertRaisesRegex(utils.Error,
'Node %s was not found' % self.uuid,
process.process, self.data)
self.cli.get_node.assert_called_once_with(self.uuid)
self.assertFalse(self.process_mock.called)
self.node_info.finished.assert_called_once_with(istate.Events.error,
error=mock.ANY)
def test_delete_NotFound(self):
self.res.delete.side_effect = exceptions.NotFoundException(
message="test", http_status=404)
self.assertRaisesRegex(exceptions.NotFoundException,
"test",
self.sot._delete,
DeleteableResource,
self.res,
ignore_missing=False)
def test_delete_NotFound(self):
self.res.delete.side_effect = exceptions.NotFoundException(
message="test", http_status=404)
self.assertRaisesRegex(
exceptions.NotFoundException,
# TODO(shade) The mocks here are hiding the thing we want to test.
"test",
self.sot._delete,
DeleteableResource,
self.res,
ignore_missing=False)
def handle_neutron_errors(method, *args, **kwargs):
"""Handle errors on openstacksdk router methods"""
result = method(*args, **kwargs)
if 'NeutronError' in result:
error = result['NeutronError']
if error['type'] in ('RouterNotFound',
'RouterInterfaceNotFoundForSubnet',
'SubnetNotFound'):
raise os_exc.NotFoundException(message=error['message'])
else:
raise os_exc.SDKException(error['type'] + ": " + error['message'])
return result
def test_get(self, mock_get):
sess = mock.Mock()
sot = stack.Stack(**FAKE)
deleted_stack = mock.Mock(id=FAKE_ID, status='DELETE_COMPLETE')
normal_stack = mock.Mock(status='CREATE_COMPLETE')
mock_get.side_effect = [
normal_stack,
exceptions.NotFoundException(message='oops'),
deleted_stack,
]
self.assertEqual(normal_stack, sot.get(sess))
ex = self.assertRaises(exceptions.NotFoundException, sot.get, sess)
self.assertEqual('oops', six.text_type(ex))
ex = self.assertRaises(exceptions.NotFoundException, sot.get, sess)
self.assertEqual('No stack found for %s' % FAKE_ID, six.text_type(ex))
def test_failed_to_get_node(self, client_mock, start_mock):
cli = client_mock.return_value
cli.get_node.side_effect = os_exc.NotFoundException()
self.assertRaisesRegex(utils.Error,
'Node %s was not found' % self.uuid,
introspect.introspect, self.uuid)
cli.get_node.side_effect = os_exc.BadRequestException()
self.assertRaisesRegex(utils.Error,
'Cannot get node %s: Error' % self.uuid,
introspect.introspect, self.uuid)
self.assertEqual(0, self.node_info.ports.call_count)
self.assertEqual(0, self.sync_filter_mock.call_count)
self.assertEqual(0, cli.set_node_power_state.call_count)
self.assertFalse(start_mock.called)
self.assertFalse(self.node_info.acquire_lock.called)
def map_exceptions_wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except _exceptions.HttpError as e:
if e.http_status == 404:
raise exceptions.NotFoundException(
message=e.message, details=e.details,
response=e.response, request_id=e.request_id,
url=e.url, method=e.method,
http_status=e.http_status, cause=e)
else:
raise exceptions.HttpException(
message=e.message, details=e.details,
response=e.response, request_id=e.request_id,
url=e.url, method=e.method,
http_status=e.http_status, cause=e)
except _exceptions.ClientException as e:
raise exceptions.SDKException(message=e.message, cause=e)
def get_datastore_version(self, datastore, datastore_version):
"""Get the detail of a datastore version
:param datastore: datastore name
:param datastore_Version: id of the datastore version
:returns: Detail of datastore version
:rtype: :class:`~otcextensions.sdk.rds.v1.datastore.Datastore`
"""
versions = self._list(
_datastore.Datastore,
paginated=False,
# endpoint_override=self.get_rds_endpoint(),
headers=self.get_os_headers(True),
# project_id=self.session.get_project_id(),
datastore_name=datastore)
for ver in versions:
if ver.id == datastore_version:
return ver
return exceptions.NotFoundException('Resource not found')
def _translate_response(self, response, has_body=None, error_message=None):
"""Given a KSA response, inflate this instance with its data
'DELETE' operations don't return a body, so only try to work
with a body when has_body is True.
This method updates attributes that correspond to headers
and body on this instance and clears the dirty set.
"""
if has_body is None:
has_body = self.has_body
# exceptions.raise_from_response(response, error_message=error_message)
if has_body:
body = response.json()
errCode = body.get('errCode', None)
if errCode and errCode == 'RDS.0041':
if self.resource_key and self.resource_key in body:
body = body[self.resource_key]
body = self._consume_body_attrs(body)
self._body.attributes.update(body)
self._body.clean()
elif errCode and errCode == 'RDS.0028':
raise exceptions.NotFoundException('Resource not found')
elif errCode and errCode != 'RDS.0041':
_logger.error('error during service invokation %s' % errCode)
raise exceptions.SDKException(
body.get('externalMessage', body)
)
elif not errCode:
if self.resource_key and self.resource_key in body:
body = body[self.resource_key]
body = self._consume_body_attrs(body)
self._body.attributes.update(body)
self._body.clean()
headers = self._consume_header_attrs(response.headers)
self._header.attributes.update(headers)
self._header.clean()
def test_get_not_found(self):
self.res.get.side_effect = exceptions.NotFoundException(
message="test", http_status=404)
self.assertRaisesRegex(exceptions.NotFoundException, "test",
self.sot._get, RetrieveableResource, self.res)
def test_delete_ignore_missing(self):
self.res.delete.side_effect = exceptions.NotFoundException(
message="test", http_status=404)
rv = self.sot._delete(DeleteableResource, self.fake_id)
self.assertIsNone(rv)
def test_store_find_node_error(self, hook_mock):
self.cli.get_node.side_effect = os_exc.NotFoundException('boom')
self.assertRaises(utils.Error, process.process, self.data)
self._check_contents()
def get(self, session, include_headers=False, args=None):
stk = super(Stack, self).get(session, include_headers, args)
if stk and stk.status in ['DELETE_COMPLETE', 'ADOPT_COMPLETE']:
raise exceptions.NotFoundException("No stack found for %s" %
stk.id)
return stk
def test_remove_not_found(self, mock_cli):
mock_cli.return_value.remove_node_trait.side_effect = (
os_exc.NotFoundException('trait not found'))
self.act.apply(self.node_info, self.params)
mock_cli.return_value.remove_node_trait.assert_called_once_with(
self.uuid, 'CUSTOM_FOO')
