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()