openstack/python-openstackclient
Code Issues Proposed changes

Merge "Migrate server_groups to the new API"

Browse Source
This commit is contained in:
Zuul 2022-08-09 17:33:39 +00:00 committed by Gerrit Code Review
commit 27b2496e03
4 changed files with 227 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
openstackclient/compute/v2/server_group.py
View File

@ -17,7 +17,7 @@
import logging import logging
from novaclient import api_versions from openstack import utils as sdk_utils
from osc_lib.cli import format_columns from osc_lib.cli import format_columns
from osc_lib.cli import parseractions from osc_lib.cli import parseractions
from osc_lib.command import command from osc_lib.command import command
@ -31,19 +31,24 @@ LOG = logging.getLogger(__name__)
_formatters = { _formatters = {
'members': format_columns.ListColumn, 'member_ids': format_columns.ListColumn,
'policies': format_columns.ListColumn, 'policies': format_columns.ListColumn,
'rules': format_columns.DictColumn, 'rules': format_columns.DictColumn,
} }
def _get_columns(info): def _get_server_group_columns(item, client):
columns = list(info.keys()) column_map = {'member_ids': 'members'}
if 'metadata' in columns: hidden_columns = ['metadata', 'location']
# NOTE(RuiChen): The metadata of server group is always empty since API
# compatible, so hide it in order to avoid confusion. if sdk_utils.supports_microversion(client, '2.64'):
columns.remove('metadata') hidden_columns.append('policies')
return tuple(sorted(columns)) else:
hidden_columns.append('policy')
hidden_columns.append('rules')
return utils.get_osc_show_columns_for_sdk_resource(
item, column_map, hidden_columns)
class CreateServerGroup(command.ShowOne): class CreateServerGroup(command.ShowOne):
@ -54,7 +59,7 @@ class CreateServerGroup(command.ShowOne):
parser.add_argument( parser.add_argument(
'name', 'name',
metavar='<name>', metavar='<name>',
help=_("New server group name") help=_("New server group name"),
) )
parser.add_argument( parser.add_argument(
'--policy', '--policy',
@ -87,11 +92,10 @@ class CreateServerGroup(command.ShowOne):
return parser return parser
def take_action(self, parsed_args): def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute compute_client = self.app.client_manager.sdk_connection.compute
info = {}
if parsed_args.policy in ('soft-affinity', 'soft-anti-affinity'): if parsed_args.policy in ('soft-affinity', 'soft-anti-affinity'):
if compute_client.api_version < api_versions.APIVersion('2.15'): if not sdk_utils.supports_microversion(compute_client, '2.15'):
msg = _( msg = _(
'--os-compute-api-version 2.15 or greater is required to ' '--os-compute-api-version 2.15 or greater is required to '
'support the %s policy' 'support the %s policy'
@ -99,30 +103,39 @@ class CreateServerGroup(command.ShowOne):
raise exceptions.CommandError(msg % parsed_args.policy) raise exceptions.CommandError(msg % parsed_args.policy)
if parsed_args.rules: if parsed_args.rules:
if compute_client.api_version < api_versions.APIVersion('2.64'): if not sdk_utils.supports_microversion(compute_client, '2.64'):
msg = _( msg = _(
'--os-compute-api-version 2.64 or greater is required to ' '--os-compute-api-version 2.64 or greater is required to '
'support the --rule option' 'support the --rule option'
) )
raise exceptions.CommandError(msg) raise exceptions.CommandError(msg)
if compute_client.api_version < api_versions.APIVersion('2.64'): if not sdk_utils.supports_microversion(compute_client, '2.64'):
kwargs = {'policies': [parsed_args.policy]} kwargs = {
'name': parsed_args.name,
'policies': [parsed_args.policy],
}
else: else:
kwargs = { kwargs = {
'name': parsed_args.name,
'policy': parsed_args.policy, 'policy': parsed_args.policy,
'rules': parsed_args.rules or None,
} }
server_group = compute_client.server_groups.create( if parsed_args.rules:
name=parsed_args.name, **kwargs) kwargs['rules'] = parsed_args.rules
info.update(server_group._info) server_group = compute_client.create_server_group(**kwargs)
columns = _get_columns(info) display_columns, columns = _get_server_group_columns(
data = utils.get_dict_properties( server_group,
info, columns, formatters=_formatters) compute_client,
return columns, data )
data = utils.get_item_properties(
server_group,
columns,
formatters=_formatters,
)
return display_columns, data
class DeleteServerGroup(command.Command): class DeleteServerGroup(command.Command):
@ -134,18 +147,17 @@ class DeleteServerGroup(command.Command):
'server_group', 'server_group',
metavar='<server-group>', metavar='<server-group>',
nargs='+', nargs='+',
help=_("server group(s) to delete (name or ID)") help=_("server group(s) to delete (name or ID)"),
) )
return parser return parser
def take_action(self, parsed_args): def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute compute_client = self.app.client_manager.sdk_connection.compute
result = 0 result = 0
for group in parsed_args.server_group: for group in parsed_args.server_group:
try: try:
group_obj = utils.find_resource(compute_client.server_groups, group_obj = compute_client.find_server_group(group)
group) compute_client.delete_server_group(group_obj.id)
compute_client.server_groups.delete(group_obj.id)
# Catch all exceptions in order to avoid to block the next deleting # Catch all exceptions in order to avoid to block the next deleting
except Exception as e: except Exception as e:
result += 1 result += 1
@ -169,13 +181,13 @@ class ListServerGroup(command.Lister):
'--all-projects', '--all-projects',
action='store_true', action='store_true',
default=False, default=False,
help=_("Display information from all projects (admin only)") help=_("Display information from all projects (admin only)"),
) )
parser.add_argument( parser.add_argument(
'--long', '--long',
action='store_true', action='store_true',
default=False, default=False,
help=_("List additional fields in output") help=_("List additional fields in output"),
) )
# TODO(stephenfin): This should really be a --marker option, but alas # TODO(stephenfin): This should really be a --marker option, but alas
# the API doesn't support that for some reason # the API doesn't support that for some reason
@ -204,7 +216,7 @@ class ListServerGroup(command.Lister):
return parser return parser
def take_action(self, parsed_args): def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute compute_client = self.app.client_manager.sdk_connection.compute
kwargs = {} kwargs = {}
@ -217,10 +229,10 @@ class ListServerGroup(command.Lister):
if parsed_args.limit: if parsed_args.limit:
kwargs['limit'] = parsed_args.limit kwargs['limit'] = parsed_args.limit
data = compute_client.server_groups.list(**kwargs) data = compute_client.server_groups(**kwargs)
policy_key = 'Policies' policy_key = 'Policies'
if compute_client.api_version >= api_versions.APIVersion("2.64"): if sdk_utils.supports_microversion(compute_client, '2.64'):
policy_key = 'Policy' policy_key = 'Policy'
columns = ( columns = (
@ -235,7 +247,7 @@ class ListServerGroup(command.Lister):
) )
if parsed_args.long: if parsed_args.long:
columns += ( columns += (
'members', 'member_ids',
'project_id', 'project_id',
'user_id', 'user_id',
) )
@ -263,17 +275,18 @@ class ShowServerGroup(command.ShowOne):
parser.add_argument( parser.add_argument(
'server_group', 'server_group',
metavar='<server-group>', metavar='<server-group>',
help=_("server group to display (name or ID)") help=_("server group to display (name or ID)"),
) )
return parser return parser
def take_action(self, parsed_args): def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute compute_client = self.app.client_manager.sdk_connection.compute
group = utils.find_resource(compute_client.server_groups, group = compute_client.find_server_group(parsed_args.server_group)
parsed_args.server_group) display_columns, columns = _get_server_group_columns(
info = {} group,
info.update(group._info) compute_client,
columns = _get_columns(info) )
data = utils.get_dict_properties( data = utils.get_item_properties(
info, columns, formatters=_formatters) group, columns, formatters=_formatters
return columns, data )
return display_columns, data

24
openstackclient/tests/functional/compute/v2/test_server_group.py
View File

@ -33,8 +33,8 @@ class ServerGroupTests(base.TestCase):
cmd_output['name'] cmd_output['name']
) )
self.assertEqual( self.assertEqual(
['affinity'], 'affinity',
cmd_output['policies'] cmd_output['policy']
) )
cmd_output = json.loads(self.openstack( cmd_output = json.loads(self.openstack(
@ -47,8 +47,8 @@ class ServerGroupTests(base.TestCase):
cmd_output['name'] cmd_output['name']
) )
self.assertEqual( self.assertEqual(
['anti-affinity'], 'anti-affinity',
cmd_output['policies'] cmd_output['policy']
) )
del_output = self.openstack( del_output = self.openstack(
@ -60,7 +60,7 @@ class ServerGroupTests(base.TestCase):
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
# test server gorup show # test server group show
cmd_output = json.loads(self.openstack( cmd_output = json.loads(self.openstack(
'server group create -f json ' + 'server group create -f json ' +
'--policy affinity ' + '--policy affinity ' +
@ -74,8 +74,8 @@ class ServerGroupTests(base.TestCase):
cmd_output['name'] cmd_output['name']
) )
self.assertEqual( self.assertEqual(
['affinity'], 'affinity',
cmd_output['policies'] cmd_output['policy']
) )
cmd_output = json.loads(self.openstack( cmd_output = json.loads(self.openstack(
@ -91,8 +91,8 @@ class ServerGroupTests(base.TestCase):
cmd_output['name'] cmd_output['name']
) )
self.assertEqual( self.assertEqual(
['anti-affinity'], 'anti-affinity',
cmd_output['policies'] cmd_output['policy']
) )
# test server group list # test server group list
@ -101,6 +101,6 @@ class ServerGroupTests(base.TestCase):
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
policies = [x["Policies"] for x in cmd_output] policies = [x["Policy"] for x in cmd_output]
self.assertIn(['affinity'], policies) self.assertIn('affinity', policies)
self.assertIn(['anti-affinity'], policies) self.assertIn('anti-affinity', policies)

95
openstackclient/tests/unit/compute/v2/fakes.py
View File

@ -21,6 +21,7 @@ import uuid
from novaclient import api_versions from novaclient import api_versions
from openstack.compute.v2 import flavor as _flavor from openstack.compute.v2 import flavor as _flavor
from openstack.compute.v2 import server from openstack.compute.v2 import server
from openstack.compute.v2 import server_group as _server_group
from openstack.compute.v2 import server_interface as _server_interface from openstack.compute.v2 import server_interface as _server_interface
from openstack.compute.v2 import service from openstack.compute.v2 import service
from openstack.compute.v2 import volume_attachment from openstack.compute.v2 import volume_attachment
@ -1290,72 +1291,6 @@ class FakeHost(object):
return host_info return host_info
class FakeServerGroup(object):
"""Fake one server group"""
@staticmethod
def _create_one_server_group(attrs=None):
"""Create a fake server group
:param dict attrs:
A dictionary with all attributes
:return:
A FakeResource object, with id and other attributes
"""
if attrs is None:
attrs = {}
# Set default attributes.
server_group_info = {
'id': 'server-group-id-' + uuid.uuid4().hex,
'members': [],
'metadata': {},
'name': 'server-group-name-' + uuid.uuid4().hex,
'project_id': 'server-group-project-id-' + uuid.uuid4().hex,
'user_id': 'server-group-user-id-' + uuid.uuid4().hex,
}
# Overwrite default attributes.
server_group_info.update(attrs)
server_group = fakes.FakeResource(
info=copy.deepcopy(server_group_info),
loaded=True)
return server_group
@staticmethod
def create_one_server_group(attrs=None):
"""Create a fake server group
:param dict attrs:
A dictionary with all attributes
:return:
A FakeResource object, with id and other attributes
"""
if attrs is None:
attrs = {}
attrs.setdefault('policies', ['policy1', 'policy2'])
return FakeServerGroup._create_one_server_group(attrs)
class FakeServerGroupV264(object):
"""Fake one server group for API >= 2.64"""
@staticmethod
def create_one_server_group(attrs=None):
"""Create a fake server group
:param dict attrs:
A dictionary with all attributes
:return:
A FakeResource object, with id and other attributes
"""
if attrs is None:
attrs = {}
attrs.setdefault('policy', 'policy1')
return FakeServerGroup._create_one_server_group(attrs)
class FakeUsage(object): class FakeUsage(object):
"""Fake one or more usage.""" """Fake one or more usage."""
@ -1860,6 +1795,34 @@ class FakeVolumeAttachment(object):
return volume_attachments return volume_attachments
def create_one_server_group(attrs=None):
"""Create a fake server group
:param dict attrs:
A dictionary with all attributes
:return:
A fake ServerGroup object, with id and other attributes
"""
if attrs is None:
attrs = {}
# Set default attributes.
server_group_info = {
'id': 'server-group-id-' + uuid.uuid4().hex,
'member_ids': '',
'metadata': {},
'name': 'server-group-name-' + uuid.uuid4().hex,
'project_id': 'server-group-project-id-' + uuid.uuid4().hex,
'user_id': 'server-group-user-id-' + uuid.uuid4().hex,
}
# Overwrite default attributes.
server_group_info.update(attrs)
server_group = _server_group.ServerGroup(**server_group_info)
return server_group
def create_one_server_interface(attrs=None): def create_one_server_interface(attrs=None):
"""Create a fake SDK ServerInterface. """Create a fake SDK ServerInterface.

281
openstackclient/tests/unit/compute/v2/test_server_group.py
View File

@ -15,10 +15,9 @@
from unittest import mock from unittest import mock
from novaclient import api_versions from openstack import utils as sdk_utils
from osc_lib.cli import format_columns from osc_lib.cli import format_columns
from osc_lib import exceptions from osc_lib import exceptions
from osc_lib import utils
from openstackclient.compute.v2 import server_group from openstackclient.compute.v2 import server_group
from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes
@ -27,38 +26,7 @@ from openstackclient.tests.unit import utils as tests_utils
class TestServerGroup(compute_fakes.TestComputev2): class TestServerGroup(compute_fakes.TestComputev2):
fake_server_group = compute_fakes.FakeServerGroup.create_one_server_group() fake_server_group = compute_fakes.create_one_server_group()
columns = (
'id',
'members',
'name',
'policies',
'project_id',
'user_id',
)
data = (
fake_server_group.id,
format_columns.ListColumn(fake_server_group.members),
fake_server_group.name,
format_columns.ListColumn(fake_server_group.policies),
fake_server_group.project_id,
fake_server_group.user_id,
)
def setUp(self):
super(TestServerGroup, self).setUp()
# Get a shortcut to the ServerGroupsManager Mock
self.server_groups_mock = self.app.client_manager.compute.server_groups
self.server_groups_mock.reset_mock()
class TestServerGroupV264(TestServerGroup):
fake_server_group = \
compute_fakes.FakeServerGroupV264.create_one_server_group()
columns = ( columns = (
'id', 'id',
@ -66,31 +34,40 @@ class TestServerGroupV264(TestServerGroup):
'name', 'name',
'policy', 'policy',
'project_id', 'project_id',
'rules',
'user_id', 'user_id',
) )
data = ( data = (
fake_server_group.id, fake_server_group.id,
format_columns.ListColumn(fake_server_group.members), format_columns.ListColumn(fake_server_group.member_ids),
fake_server_group.name, fake_server_group.name,
fake_server_group.policy, fake_server_group.policy,
fake_server_group.project_id, fake_server_group.project_id,
format_columns.DictColumn(fake_server_group.rules),
fake_server_group.user_id, fake_server_group.user_id,
) )
def setUp(self): def setUp(self):
super(TestServerGroupV264, self).setUp() super().setUp()
# Create and get a shortcut to the compute client mock
self.app.client_manager.sdk_connection = mock.Mock()
self.sdk_client = self.app.client_manager.sdk_connection.compute
self.sdk_client.reset_mock()
class TestServerGroupCreate(TestServerGroup): class TestServerGroupCreate(TestServerGroup):
def setUp(self): def setUp(self):
super(TestServerGroupCreate, self).setUp() super().setUp()
self.server_groups_mock.create.return_value = self.fake_server_group self.sdk_client.create_server_group.return_value = \
self.fake_server_group
self.cmd = server_group.CreateServerGroup(self.app, None) self.cmd = server_group.CreateServerGroup(self.app, None)
def test_server_group_create(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_create(self, sm_mock):
arglist = [ arglist = [
'--policy', 'anti-affinity', '--policy', 'anti-affinity',
'affinity_group', 'affinity_group',
@ -101,18 +78,16 @@ class TestServerGroupCreate(TestServerGroup):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args) columns, data = self.cmd.take_action(parsed_args)
self.server_groups_mock.create.assert_called_once_with( self.sdk_client.create_server_group.assert_called_once_with(
name=parsed_args.name, name=parsed_args.name,
policies=[parsed_args.policy], policy=parsed_args.policy,
) )
self.assertCountEqual(self.columns, columns) self.assertCountEqual(self.columns, columns)
self.assertCountEqual(self.data, data) self.assertCountEqual(self.data, data)
def test_server_group_create_with_soft_policies(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
self.app.client_manager.compute.api_version = api_versions.APIVersion( def test_server_group_create_with_soft_policies(self, sm_mock):
'2.15')
arglist = [ arglist = [
'--policy', 'soft-anti-affinity', '--policy', 'soft-anti-affinity',
'affinity_group', 'affinity_group',
@ -123,18 +98,16 @@ class TestServerGroupCreate(TestServerGroup):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args) columns, data = self.cmd.take_action(parsed_args)
self.server_groups_mock.create.assert_called_once_with( self.sdk_client.create_server_group.assert_called_once_with(
name=parsed_args.name, name=parsed_args.name,
policies=[parsed_args.policy], policy=parsed_args.policy,
) )
self.assertCountEqual(self.columns, columns) self.assertCountEqual(self.columns, columns)
self.assertCountEqual(self.data, data) self.assertCountEqual(self.data, data)
def test_server_group_create_with_soft_policies_pre_v215(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False)
self.app.client_manager.compute.api_version = api_versions.APIVersion( def test_server_group_create_with_soft_policies_pre_v215(self, sm_mock):
'2.14')
arglist = [ arglist = [
'--policy', 'soft-anti-affinity', '--policy', 'soft-anti-affinity',
'affinity_group', 'affinity_group',
@ -152,10 +125,8 @@ class TestServerGroupCreate(TestServerGroup):
'--os-compute-api-version 2.15 or greater is required', '--os-compute-api-version 2.15 or greater is required',
str(ex)) str(ex))
def test_server_group_create_with_rules(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
self.app.client_manager.compute.api_version = api_versions.APIVersion( def test_server_group_create_with_rules(self, sm_mock):
'2.64')
arglist = [ arglist = [
'--policy', 'soft-anti-affinity', '--policy', 'soft-anti-affinity',
'--rule', 'max_server_per_host=2', '--rule', 'max_server_per_host=2',
@ -168,19 +139,18 @@ class TestServerGroupCreate(TestServerGroup):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args) columns, data = self.cmd.take_action(parsed_args)
self.server_groups_mock.create.assert_called_once_with( self.sdk_client.create_server_group.assert_called_once_with(
name=parsed_args.name, name=parsed_args.name,
policy=parsed_args.policy, # should be 'policy', not 'policies' policy=parsed_args.policy,
rules=parsed_args.rules, rules=parsed_args.rules,
) )
self.assertCountEqual(self.columns, columns) self.assertCountEqual(self.columns, columns)
self.assertCountEqual(self.data, data) self.assertCountEqual(self.data, data)
def test_server_group_create_with_rules_pre_v264(self): @mock.patch.object(
self.app.client_manager.compute.api_version = api_versions.APIVersion( sdk_utils, 'supports_microversion', side_effect=[True, False])
'2.63') def test_server_group_create_with_rules_pre_v264(self, sm_mock):
arglist = [ arglist = [
'--policy', 'soft-anti-affinity', '--policy', 'soft-anti-affinity',
'--rule', 'max_server_per_host=2', '--rule', 'max_server_per_host=2',
@ -205,9 +175,9 @@ class TestServerGroupCreate(TestServerGroup):
class TestServerGroupDelete(TestServerGroup): class TestServerGroupDelete(TestServerGroup):
def setUp(self): def setUp(self):
super(TestServerGroupDelete, self).setUp() super().setUp()
self.server_groups_mock.get.return_value = self.fake_server_group self.sdk_client.find_server_group.return_value = self.fake_server_group
self.cmd = server_group.DeleteServerGroup(self.app, None) self.cmd = server_group.DeleteServerGroup(self.app, None)
def test_server_group_delete(self): def test_server_group_delete(self):
@ -219,8 +189,10 @@ class TestServerGroupDelete(TestServerGroup):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args) result = self.cmd.take_action(parsed_args)
self.server_groups_mock.get.assert_called_once_with('affinity_group') self.sdk_client.find_server_group.assert_called_once_with(
self.server_groups_mock.delete.assert_called_once_with( 'affinity_group'
)
self.sdk_client.delete_server_group.assert_called_once_with(
self.fake_server_group.id self.fake_server_group.id
) )
self.assertIsNone(result) self.assertIsNone(result)
@ -235,13 +207,15 @@ class TestServerGroupDelete(TestServerGroup):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args) result = self.cmd.take_action(parsed_args)
self.server_groups_mock.get.assert_any_call('affinity_group') self.sdk_client.find_server_group.assert_any_call('affinity_group')
self.server_groups_mock.get.assert_any_call('anti_affinity_group') self.sdk_client.find_server_group.assert_any_call(
self.server_groups_mock.delete.assert_called_with( 'anti_affinity_group'
)
self.sdk_client.delete_server_group.assert_called_with(
self.fake_server_group.id self.fake_server_group.id
) )
self.assertEqual(2, self.server_groups_mock.get.call_count) self.assertEqual(2, self.sdk_client.find_server_group.call_count)
self.assertEqual(2, self.server_groups_mock.delete.call_count) self.assertEqual(2, self.sdk_client.delete_server_group.call_count)
self.assertIsNone(result) self.assertIsNone(result)
def test_server_group_delete_no_input(self): def test_server_group_delete_no_input(self):
@ -262,25 +236,23 @@ class TestServerGroupDelete(TestServerGroup):
('server_group', ['affinity_group', 'anti_affinity_group']), ('server_group', ['affinity_group', 'anti_affinity_group']),
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self.fake_server_group, exceptions.CommandError]
with mock.patch.object(utils, 'find_resource',
side_effect=find_mock_result) as find_mock:
try:
self.cmd.take_action(parsed_args)
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual('1 of 2 server groups failed to delete.',
str(e))
find_mock.assert_any_call(self.server_groups_mock, self.sdk_client.find_server_group.side_effect = [
'affinity_group') self.fake_server_group, exceptions.CommandError]
find_mock.assert_any_call(self.server_groups_mock, try:
'anti_affinity_group') self.cmd.take_action(parsed_args)
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual('1 of 2 server groups failed to delete.', str(e))
self.assertEqual(2, find_mock.call_count) self.sdk_client.find_server_group.assert_any_call('affinity_group')
self.server_groups_mock.delete.assert_called_once_with( self.sdk_client.find_server_group.assert_any_call(
self.fake_server_group.id 'anti_affinity_group'
) )
self.assertEqual(2, self.sdk_client.find_server_group.call_count)
self.sdk_client.delete_server_group.assert_called_once_with(
self.fake_server_group.id
)
class TestServerGroupList(TestServerGroup): class TestServerGroupList(TestServerGroup):
@ -300,28 +272,67 @@ class TestServerGroupList(TestServerGroup):
'User Id', 'User Id',
) )
list_columns_v264 = (
'ID',
'Name',
'Policy',
)
list_columns_v264_long = (
'ID',
'Name',
'Policy',
'Members',
'Project Id',
'User Id',
)
list_data = (( list_data = ((
TestServerGroup.fake_server_group.id, TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name, TestServerGroup.fake_server_group.name,
format_columns.ListColumn(TestServerGroup.fake_server_group.policies), format_columns.ListColumn(
TestServerGroup.fake_server_group.policies
),
),) ),)
list_data_long = (( list_data_long = ((
TestServerGroup.fake_server_group.id, TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name, TestServerGroup.fake_server_group.name,
format_columns.ListColumn(TestServerGroup.fake_server_group.policies), format_columns.ListColumn(
format_columns.ListColumn(TestServerGroup.fake_server_group.members), TestServerGroup.fake_server_group.policies
),
format_columns.ListColumn(
TestServerGroup.fake_server_group.member_ids
),
TestServerGroup.fake_server_group.project_id,
TestServerGroup.fake_server_group.user_id,
),)
list_data_v264 = ((
TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name,
TestServerGroup.fake_server_group.policy,
),)
list_data_v264_long = ((
TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name,
TestServerGroup.fake_server_group.policy,
format_columns.ListColumn(
TestServerGroup.fake_server_group.member_ids
),
TestServerGroup.fake_server_group.project_id, TestServerGroup.fake_server_group.project_id,
TestServerGroup.fake_server_group.user_id, TestServerGroup.fake_server_group.user_id,
),) ),)
def setUp(self): def setUp(self):
super(TestServerGroupList, self).setUp() super().setUp()
self.server_groups_mock.list.return_value = [self.fake_server_group] self.sdk_client.server_groups.return_value = [self.fake_server_group]
self.cmd = server_group.ListServerGroup(self.app, None) self.cmd = server_group.ListServerGroup(self.app, None)
def test_server_group_list(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False)
def test_server_group_list(self, sm_mock):
arglist = [] arglist = []
verifylist = [ verifylist = [
('all_projects', False), ('all_projects', False),
@ -332,12 +343,13 @@ class TestServerGroupList(TestServerGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args) columns, data = self.cmd.take_action(parsed_args)
self.server_groups_mock.list.assert_called_once_with() self.sdk_client.server_groups.assert_called_once_with()
self.assertCountEqual(self.list_columns, columns) self.assertCountEqual(self.list_columns, columns)
self.assertCountEqual(self.list_data, tuple(data)) self.assertCountEqual(self.list_data, tuple(data))
def test_server_group_list_with_all_projects_and_long(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False)
def test_server_group_list_with_all_projects_and_long(self, sm_mock):
arglist = [ arglist = [
'--all-projects', '--all-projects',
'--long', '--long',
@ -350,13 +362,14 @@ class TestServerGroupList(TestServerGroup):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args) columns, data = self.cmd.take_action(parsed_args)
self.server_groups_mock.list.assert_called_once_with( self.sdk_client.server_groups.assert_called_once_with(
all_projects=True) all_projects=True)
self.assertCountEqual(self.list_columns_long, columns) self.assertCountEqual(self.list_columns_long, columns)
self.assertCountEqual(self.list_data_long, tuple(data)) self.assertCountEqual(self.list_data_long, tuple(data))
def test_server_group_list_with_limit(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_list_with_limit(self, sm_mock):
arglist = [ arglist = [
'--limit', '1', '--limit', '1',
] ]
@ -370,9 +383,10 @@ class TestServerGroupList(TestServerGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args) self.cmd.take_action(parsed_args)
self.server_groups_mock.list.assert_called_once_with(limit=1) self.sdk_client.server_groups.assert_called_once_with(limit=1)
def test_server_group_list_with_offset(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_list_with_offset(self, sm_mock):
arglist = [ arglist = [
'--offset', '5', '--offset', '5',
] ]
@ -386,51 +400,10 @@ class TestServerGroupList(TestServerGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args) self.cmd.take_action(parsed_args)
self.server_groups_mock.list.assert_called_once_with(offset=5) self.sdk_client.server_groups.assert_called_once_with(offset=5)
@mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
class TestServerGroupListV264(TestServerGroupV264): def test_server_group_list_v264(self, sm_mock):
list_columns = (
'ID',
'Name',
'Policy',
)
list_columns_long = (
'ID',
'Name',
'Policy',
'Members',
'Project Id',
'User Id',
)
list_data = ((
TestServerGroupV264.fake_server_group.id,
TestServerGroupV264.fake_server_group.name,
TestServerGroupV264.fake_server_group.policy,
),)
list_data_long = ((
TestServerGroupV264.fake_server_group.id,
TestServerGroupV264.fake_server_group.name,
TestServerGroupV264.fake_server_group.policy,
format_columns.ListColumn(
TestServerGroupV264.fake_server_group.members),
TestServerGroupV264.fake_server_group.project_id,
TestServerGroupV264.fake_server_group.user_id,
),)
def setUp(self):
super(TestServerGroupListV264, self).setUp()
self.server_groups_mock.list.return_value = [self.fake_server_group]
self.cmd = server_group.ListServerGroup(self.app, None)
self.app.client_manager.compute.api_version = api_versions.APIVersion(
'2.64')
def test_server_group_list(self):
arglist = [] arglist = []
verifylist = [ verifylist = [
('all_projects', False), ('all_projects', False),
@ -438,12 +411,13 @@ class TestServerGroupListV264(TestServerGroupV264):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args) columns, data = self.cmd.take_action(parsed_args)
self.server_groups_mock.list.assert_called_once_with() self.sdk_client.server_groups.assert_called_once_with()
self.assertCountEqual(self.list_columns, columns) self.assertCountEqual(self.list_columns_v264, columns)
self.assertCountEqual(self.list_data, tuple(data)) self.assertCountEqual(self.list_data_v264, tuple(data))
def test_server_group_list_with_all_projects_and_long(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_list_with_all_projects_and_long_v264(self, sm_mock):
arglist = [ arglist = [
'--all-projects', '--all-projects',
'--long', '--long',
@ -454,22 +428,23 @@ class TestServerGroupListV264(TestServerGroupV264):
] ]
parsed_args = self.check_parser(self.cmd, arglist, verifylist) parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args) columns, data = self.cmd.take_action(parsed_args)
self.server_groups_mock.list.assert_called_once_with( self.sdk_client.server_groups.assert_called_once_with(
all_projects=True) all_projects=True)
self.assertCountEqual(self.list_columns_long, columns) self.assertCountEqual(self.list_columns_v264_long, columns)
self.assertCountEqual(self.list_data_long, tuple(data)) self.assertCountEqual(self.list_data_v264_long, tuple(data))
class TestServerGroupShow(TestServerGroup): class TestServerGroupShow(TestServerGroup):
def setUp(self): def setUp(self):
super(TestServerGroupShow, self).setUp() super().setUp()
self.server_groups_mock.get.return_value = self.fake_server_group self.sdk_client.find_server_group.return_value = self.fake_server_group
self.cmd = server_group.ShowServerGroup(self.app, None) self.cmd = server_group.ShowServerGroup(self.app, None)
def test_server_group_show(self): @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_show(self, sm_mock):
arglist = [ arglist = [
'affinity_group', 'affinity_group',
] ]