def test_image_create_with_unexist_project(self):
self.project_mock.get.side_effect = exceptions.NotFound(None)
self.project_mock.find.side_effect = exceptions.NotFound(None)
arglist = [
'--container-format', 'ovf',
'--disk-format', 'ami',
'--min-disk', '10',
'--min-ram', '4',
'--protected',
'--private',
'--project', 'unexist_owner',
image_fakes.image_name,
]
verifylist = [
('container_format', 'ovf'),
('disk_format', 'ami'),
('min_disk', 10),
('min_ram', 4),
('protected', True),
('unprotected', False),
('public', False),
('private', True),
('project', 'unexist_owner'),
('name', image_fakes.image_name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(
exceptions.CommandError,
self.cmd.take_action,
parsed_args,
)
def test_project_create_invalid_parent(self):
self.projects_mock.resource_class.__name__ = 'Project'
self.projects_mock.get.side_effect = exceptions.NotFound(
'Invalid parent')
self.projects_mock.find.side_effect = exceptions.NotFound(
'Invalid parent')
arglist = [
'--domain',
self.project.domain_id,
'--parent',
'invalid',
self.project.name,
]
verifylist = [
('domain', self.project.domain_id),
('parent', 'invalid'),
('enable', False),
('disable', False),
('name', self.project.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(
exceptions.CommandError,
self.cmd.take_action,
parsed_args,
)
def test_delete_multiple_meter_exception(self):
arglist = [
self.meter_list[0].id,
'xxxx-yyyy-zzzz',
self.meter_list[1].id,
]
verifylist = [
('meter', arglist),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
return_find = [
self.meter_list[0],
exceptions.NotFound('404'),
self.meter_list[1],
]
self.network.find_meter = mock.Mock(side_effect=return_find)
ret_delete = [
None,
exceptions.NotFound('404'),
]
self.network.delete_metering_label = mock.Mock(side_effect=ret_delete)
self.assertRaises(exceptions.CommandError, self.cmd.take_action,
parsed_args)
calls = [
call(self.meter_list[0]),
call(self.meter_list[1]),
]
self.network.delete_metering_label.assert_has_calls(calls)
def test_delete_with_pool_not_found(self):
self._create_stack()
self.member.resource_id_set('1234')
m_get_pool = mock.Mock(side_effect=exceptions.NotFound(404))
self.member.client_plugin().get_pool = m_get_pool
self.octavia_client.member_delete.side_effect = [
exceptions.NotFound(404)
]
self.member.translate_properties(self.member.properties,
ignore_resolve_error=True)
self.member.handle_delete()
self.assertTrue(self.member.check_delete_complete(None))
self.octavia_client.member_delete.assert_called_with('123', '1234')
def test_flavor_unset_with_unexist_flavor(self):
self.flavors_mock.get.side_effect = exceptions.NotFound(None)
self.flavors_mock.find.side_effect = exceptions.NotFound(None)
arglist = [
'--project', self.project.id,
'unexist_flavor',
]
verifylist = [
('project', self.project.id),
('flavor', 'unexist_flavor'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(exceptions.CommandError, self.cmd.take_action,
parsed_args)
def test_multi_floating_ips_delete_with_exception(self):
arglist = [
self.floating_ips[0].id,
'unexist_floating_ip',
]
verifylist = [
('floating_ip', [self.floating_ips[0].id, 'unexist_floating_ip']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self.floating_ips[0], exceptions.CommandError]
self.compute.floating_ips.get = (mock.Mock(
side_effect=find_mock_result))
self.compute.floating_ips.find.side_effect = exceptions.NotFound(None)
try:
self.cmd.take_action(parsed_args)
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual('1 of 2 floating_ips failed to delete.', str(e))
self.compute.floating_ips.get.assert_any_call(self.floating_ips[0].id)
self.compute.floating_ips.get.assert_any_call('unexist_floating_ip')
self.compute.floating_ips.delete.assert_called_once_with(
self.floating_ips[0].id)
def find(
self,
path,
value=None,
attr=None,
):
"""Find a single resource by name or ID
:param string path:
The API-specific portion of the URL path
:param string value:
search expression (required, really)
:param string attr:
name of attribute for secondary search
"""
try:
ret = self._request('GET', "/%s/%s" % (path, value)).json()
if isinstance(ret, dict):
# strip off the enclosing dict
key = list(ret.keys())[0]
ret = ret[key]
except (
ksa_exceptions.NotFound,
ksa_exceptions.BadRequest,
):
kwargs = {attr: value}
try:
ret = self.find_one(path, **kwargs)
except ksa_exceptions.NotFound:
msg = _("%s not found") % value
raise exceptions.NotFound(msg)
return ret
def find(
self,
path,
value=None,
attr=None,
):
"""Find a single resource by name or ID
:param string path:
The API-specific portion of the URL path
:param string value:
search expression
:param string attr:
name of attribute for secondary search
"""
try:
ret = self._request('GET', "/%s/%s" % (path, value)).json()
except ks_exceptions.NotFound:
kwargs = {attr: value}
try:
ret = self.find_one("/%s/detail" % (path), **kwargs)
except ks_exceptions.NotFound:
msg = _("%s not found") % value
raise exceptions.NotFound(msg)
return ret
def test_type_set_new_encryption_without_provider(self):
self.encryption_types_mock.update.side_effect = (
exceptions.NotFound('NotFound'))
arglist = [
'--encryption-cipher', 'aes-xts-plain64',
'--encryption-key-size', '128',
'--encryption-control-location', 'front-end',
self.volume_type.id,
]
verifylist = [
('encryption_cipher', 'aes-xts-plain64'),
('encryption_key_size', 128),
('encryption_control_location', 'front-end'),
('volume_type', self.volume_type.id),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
try:
self.cmd.take_action(parsed_args)
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual("Command Failed: One or more of"
" the operations failed",
str(e))
body = {
'cipher': 'aes-xts-plain64',
'key_size': 128,
'control_location': 'front-end',
}
self.encryption_types_mock.update.assert_called_with(
self.volume_type,
body,
)
self.encryption_types_mock.create.assert_not_called()
def test_image_delete_multi_images_exception(self):
images = image_fakes.FakeImage.create_images(count=2)
arglist = [
images[0].id,
images[1].id,
'x-y-x',
]
verifylist = [('images', arglist)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# Fake exception in utils.find_resource()
# In image v2, we use utils.find_resource() to find a network.
# It calls get() several times, but find() only one time. So we
# choose to fake get() always raise exception, then pass through.
# And fake find() to find the real network or not.
ret_find = [
images[0],
images[1],
exceptions.NotFound('404'),
]
self.images_mock.get = Exception()
self.images_mock.find.side_effect = ret_find
self.assertRaises(exceptions.CommandError, self.cmd.take_action,
parsed_args)
calls = [mock.call(i.id) for i in images]
self.images_mock.delete.assert_has_calls(calls)
def test_qos_list_no_association(self):
self.qos_mock.reset_mock()
self.qos_mock.get_associations.side_effect = [
[self.qos_association],
exceptions.NotFound("NotFound"),
]
arglist = []
verifylist = []
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.qos_mock.list.assert_called_with()
self.assertEqual(self.columns, columns)
ex_data = copy.deepcopy(self.data)
ex_data[1] = (
self.qos_specs[1].id,
self.qos_specs[1].name,
self.qos_specs[1].consumer,
None,
utils.format_dict(self.qos_specs[1].specs),
)
self.assertEqual(ex_data, list(data))
def test_type_set_new_encryption(self):
self.encryption_types_mock.update.side_effect = (
exceptions.NotFound('NotFound'))
arglist = [
'--encryption-provider', 'LuksEncryptor',
'--encryption-cipher', 'aes-xts-plain64',
'--encryption-key-size', '128',
'--encryption-control-location', 'front-end',
self.volume_type.id,
]
verifylist = [
('encryption_provider', 'LuksEncryptor'),
('encryption_cipher', 'aes-xts-plain64'),
('encryption_key_size', 128),
('encryption_control_location', 'front-end'),
('volume_type', self.volume_type.id),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
body = {
'provider': 'LuksEncryptor',
'cipher': 'aes-xts-plain64',
'key_size': 128,
'control_location': 'front-end',
}
self.encryption_types_mock.update.assert_called_with(
self.volume_type,
body,
)
self.encryption_types_mock.create.assert_called_with(
self.volume_type,
body,
)
self.assertIsNone(result)
def test_delete_already_gone(self):
self._create_stack()
self.l7rule.resource_id_set('1234')
self.octavia_client.l7rule_delete.side_effect = (
exceptions.NotFound(404))
self.l7rule.handle_delete()
self.assertTrue(self.l7rule.check_delete_complete(None))
def test_image_set_with_unexist_project(self):
self.project_mock.get.side_effect = exceptions.NotFound(None)
self.project_mock.find.side_effect = exceptions.NotFound(None)
arglist = [
'--project',
'unexist_owner',
image_fakes.image_id,
]
verifylist = [
('project', 'unexist_owner'),
('image', image_fakes.image_id),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(exceptions.CommandError, self.cmd.take_action,
parsed_args)
def setUp(self):
super(TestFlavorUnset, self).setUp()
self.flavors_mock.find.return_value = self.flavor
self.flavors_mock.get.side_effect = exceptions.NotFound(None)
# Return a project
self.projects_mock.get.return_value = self.project
self.cmd = flavor.UnsetFlavor(self.app, None)
def setUp(self):
super(TestFlavorShow, self).setUp()
# Return value of _find_resource()
self.flavors_mock.find.return_value = self.flavor
self.flavors_mock.get.side_effect = exceptions.NotFound(None)
self.flavor_access_mock.list.return_value = [self.flavor_access]
self.cmd = flavor.ShowFlavor(self.app, None)
def test_cluster_template_delete_bad_uuid(self):
self.cluster_templates_mock.delete.side_effect = (
osc_exceptions.NotFound(404))
arglist = ['foo']
verifylist = [('cluster-templates', ['foo'])]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
returns = self.cmd.take_action(parsed_args)
self.assertEqual(returns, None)
def test_project_set_unexist_project(self):
arglist = [
"unexist-project",
]
verifylist = [
('project', "unexist-project"),
('name', None),
('description', None),
('enable', False),
('disable', False),
('property', None),
]
self.projects_mock.get.side_effect = exceptions.NotFound(None)
self.projects_mock.find.side_effect = exceptions.NotFound(None)
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(
exceptions.CommandError, self.cmd.take_action, parsed_args)
def test_server_show_with_name_specified(self, mock_list, mock_get):
args = [self.fake_server.name]
verify_args = [('server', self.fake_server.name)]
parsed_args = self.check_parser(self.cmd, args, verify_args)
mock_get.side_effect = [exceptions.NotFound(404),
self.fake_server]
mock_list.return_value = [self.fake_server]
self.cmd.take_action(parsed_args)
expected = [mock.call('/servers/%s' % self.fake_server.name),
mock.call('/servers/%s' % self.fake_server.uuid)]
self.assertEqual(expected, mock_get.call_args_list)
def test_user_set_unexist_user(self):
arglist = [
"unexist-user",
]
verifylist = [
('name', None),
('password', None),
('email', None),
('project', None),
('enable', False),
('disable', False),
('user', "unexist-user"),
]
self.users_mock.get.side_effect = exceptions.NotFound(None)
self.users_mock.find.side_effect = exceptions.NotFound(None)
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(exceptions.CommandError, self.cmd.take_action,
parsed_args)
def test_find_resource_find_not_found(self):
self.manager.get = mock.Mock(side_effect=Exception('Boom!'))
self.manager.find = mock.Mock(
side_effect=exceptions.NotFound(404, "2"))
result = self.assertRaises(exceptions.CommandError,
utils.find_resource, self.manager,
self.name)
self.assertEqual("No lego with a name or ID of 'legos' exists.",
str(result))
self.manager.get.assert_called_with(self.name)
self.manager.find.assert_called_with(name=self.name)
def test_delete_value_error_with_not_found(self):
self._prepare_delete_with_value_error()
m_get_pool = mock.Mock(side_effect=exceptions.NotFound(404))
self.member.client_plugin().get_pool = m_get_pool
self.member.handle_delete()
self.assertTrue(self.member.check_delete_complete(None))
m_get_pool.assert_called_once_with(123)
self.assertFalse(self.member._delete_called)
self.assertEqual(0, self.octavia_client.member_delete.call_count)
self.m_gpv.assert_called_once_with('pool')
def test_is_deleted_true(self):
from osc_lib import exceptions as osc_exc
clients = mock.MagicMock()
octavia_client = clients.octavia.return_value
octavia_client.some_show.side_effect = osc_exc.NotFound(404, "foo")
resource = OctaviaSimpleResource(
user=clients, resource={"id": "test_id"})
self.assertTrue(resource.is_deleted())
octavia_client.some_show.assert_called_once_with("test_id")
def test_wait_for_delete_ok(self, mock_sleep):
# Tests the normal flow that the resource is deleted with a 404 coming
# back on the 2nd iteration of the wait loop.
resource = mock.MagicMock(status='ACTIVE', progress=None)
mock_get = mock.Mock(side_effect=[resource, exceptions.NotFound(404)])
manager = mock.MagicMock(get=mock_get)
res_id = str(uuid.uuid4())
callback = mock.Mock()
self.assertTrue(
utils.wait_for_delete(manager, res_id, callback=callback))
mock_sleep.assert_called_once_with(5)
callback.assert_called_once_with(0)
def test_hypervisor_list_matching_option_not_found(self):
arglist = [
'--matching',
'xxx',
]
verifylist = [
('matching', 'xxx'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# Fake exception raised from search()
self.hypervisors_mock.search.side_effect = exceptions.NotFound(None)
self.assertRaises(exceptions.NotFound, self.cmd.take_action,
parsed_args)
def test_delete_multiple_networks_exception(self):
arglist = [
self._networks[0].id,
'xxxx-yyyy-zzzz',
self._networks[1].id,
]
verifylist = [
('network', arglist),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# Fake exception in find_network()
ret_find = [
self._networks[0],
exceptions.NotFound('404'),
self._networks[1],
]
self.network.find_network = mock.Mock(side_effect=ret_find)
# Fake exception in delete_network()
ret_delete = [
None,
exceptions.NotFound('404'),
]
self.network.delete_network = mock.Mock(side_effect=ret_delete)
self.assertRaises(exceptions.CommandError, self.cmd.take_action,
parsed_args)
# The second call of find_network() should fail. So delete_network()
# was only called twice.
calls = [
call(self._networks[0]),
call(self._networks[1]),
]
self.network.delete_network.assert_has_calls(calls)
def test_delete_not_found(self):
self._create_stack()
self.listener.resource_id_set('1234')
self.octavia_client.listener_show.side_effect = [
{'provisioning_status': 'PENDING_DELETE'},
]
self.octavia_client.listener_delete.side_effect = [
exceptions.Conflict(409),
exceptions.NotFound(404)]
self.listener.handle_delete()
self.assertFalse(self.listener.check_delete_complete(None))
self.assertFalse(self.listener._delete_called)
self.octavia_client.listener_delete.assert_called_with('1234')
self.assertTrue(self.listener.check_delete_complete(None))
self.octavia_client.listener_delete.assert_called_with('1234')
def test_delete_error(self):
self._create_stack()
self.octavia_client.load_balancer_show.side_effect = [
{'provisioning_status': 'DELETE_PENDING'},
]
self.octavia_client.load_balancer_delete.side_effect = [
exceptions.Conflict(409),
exceptions.NotFound(404)
]
self.lb.handle_delete()
self.assertFalse(self.lb.check_delete_complete(None))
self.assertTrue(self.lb.check_delete_complete(None))
self.octavia_client.load_balancer_delete.assert_called_with('1234')
self.assertEqual(
2, self.octavia_client.load_balancer_delete.call_count)
def find_one(self, path, **kwargs):
"""Find a resource by name or ID
:param string path:
The API-specific portion of the URL path
:returns:
resource dict
"""
bulk_list = self.find_bulk(path, **kwargs)
num_bulk = len(bulk_list)
if num_bulk == 0:
msg = _("none found")
raise exceptions.NotFound(404, msg)
elif num_bulk > 1:
msg = _("many found")
raise RuntimeError(msg)
return bulk_list[0]
def test_create_with_invalid_resource_type(self):
name = self.res['name']
resource_type = 'invalid_resource_type'
resource_id = 'valid_fwg_id'
with mock.patch.object(self.neutronclient,
'find_resource',
side_effect=exceptions.NotFound(code=0)):
arglist = [
name, '--resource-type', resource_type, '--resource',
resource_id
]
verifylist = [('name', name), ('resource_type', resource_type),
('resource', resource_id)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(exceptions.NotFound, self.cmd.take_action,
parsed_args)
self.neutronclient.find_resource.assert_called_with(
resource_type, resource_id, cmd_resource=None)
self.mocked.assert_not_called()
