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
from novaclient import api_versions
from openstack import utils as sdk_utils
from osc_lib.cli import format_columns
from osc_lib.cli import parseractions
from osc_lib.command import command
@ -31,19 +31,24 @@ LOG = logging.getLogger(__name__)
_formatters = {
'members': format_columns.ListColumn,
'member_ids': format_columns.ListColumn,
'policies': format_columns.ListColumn,
'rules': format_columns.DictColumn,
}
def _get_columns(info):
columns = list(info.keys())
if 'metadata' in columns:
# NOTE(RuiChen): The metadata of server group is always empty since API
# compatible, so hide it in order to avoid confusion.
columns.remove('metadata')
return tuple(sorted(columns))
def _get_server_group_columns(item, client):
column_map = {'member_ids': 'members'}
hidden_columns = ['metadata', 'location']
if sdk_utils.supports_microversion(client, '2.64'):
hidden_columns.append('policies')
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):
@ -54,7 +59,7 @@ class CreateServerGroup(command.ShowOne):
parser.add_argument(
'name',
metavar='<name>',
help=_("New server group name")
help=_("New server group name"),
)
parser.add_argument(
'--policy',
@ -87,11 +92,10 @@ class CreateServerGroup(command.ShowOne):
return parser
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
info = {}
compute_client = self.app.client_manager.sdk_connection.compute
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 = _(
'--os-compute-api-version 2.15 or greater is required to '
'support the %s policy'
@ -99,30 +103,39 @@ class CreateServerGroup(command.ShowOne):
raise exceptions.CommandError(msg % parsed_args.policy)
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 = _(
'--os-compute-api-version 2.64 or greater is required to '
'support the --rule option'
)
raise exceptions.CommandError(msg)
if compute_client.api_version < api_versions.APIVersion('2.64'):
kwargs = {'policies': [parsed_args.policy]}
if not sdk_utils.supports_microversion(compute_client, '2.64'):
kwargs = {
'name': parsed_args.name,
'policies': [parsed_args.policy],
}
else:
kwargs = {
'name': parsed_args.name,
'policy': parsed_args.policy,
'rules': parsed_args.rules or None,
}
server_group = compute_client.server_groups.create(
name=parsed_args.name, **kwargs)
if parsed_args.rules:
kwargs['rules'] = parsed_args.rules
info.update(server_group._info)
server_group = compute_client.create_server_group(**kwargs)
columns = _get_columns(info)
data = utils.get_dict_properties(
info, columns, formatters=_formatters)
return columns, data
display_columns, columns = _get_server_group_columns(
server_group,
compute_client,
)
data = utils.get_item_properties(
server_group,
columns,
formatters=_formatters,
)
return display_columns, data
class DeleteServerGroup(command.Command):
@ -134,18 +147,17 @@ class DeleteServerGroup(command.Command):
'server_group',
metavar='<server-group>',
nargs='+',
help=_("server group(s) to delete (name or ID)")
help=_("server group(s) to delete (name or ID)"),
)
return parser
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
compute_client = self.app.client_manager.sdk_connection.compute
result = 0
for group in parsed_args.server_group:
try:
group_obj = utils.find_resource(compute_client.server_groups,
group)
compute_client.server_groups.delete(group_obj.id)
group_obj = compute_client.find_server_group(group)
compute_client.delete_server_group(group_obj.id)
# Catch all exceptions in order to avoid to block the next deleting
except Exception as e:
result += 1
@ -169,13 +181,13 @@ class ListServerGroup(command.Lister):
'--all-projects',
action='store_true',
default=False,
help=_("Display information from all projects (admin only)")
help=_("Display information from all projects (admin only)"),
)
parser.add_argument(
'--long',
action='store_true',
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
# the API doesn't support that for some reason
@ -204,7 +216,7 @@ class ListServerGroup(command.Lister):
return parser
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
compute_client = self.app.client_manager.sdk_connection.compute
kwargs = {}
@ -217,10 +229,10 @@ class ListServerGroup(command.Lister):
if parsed_args.limit:
kwargs['limit'] = parsed_args.limit
data = compute_client.server_groups.list(**kwargs)
data = compute_client.server_groups(**kwargs)
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'
columns = (
@ -235,7 +247,7 @@ class ListServerGroup(command.Lister):
)
if parsed_args.long:
columns += (
'members',
'member_ids',
'project_id',
'user_id',
)
@ -263,17 +275,18 @@ class ShowServerGroup(command.ShowOne):
parser.add_argument(
'server_group',
metavar='<server-group>',
help=_("server group to display (name or ID)")
help=_("server group to display (name or ID)"),
)
return parser
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
group = utils.find_resource(compute_client.server_groups,
parsed_args.server_group)
info = {}
info.update(group._info)
columns = _get_columns(info)
data = utils.get_dict_properties(
info, columns, formatters=_formatters)
return columns, data
compute_client = self.app.client_manager.sdk_connection.compute
group = compute_client.find_server_group(parsed_args.server_group)
display_columns, columns = _get_server_group_columns(
group,
compute_client,
)
data = utils.get_item_properties(
group, columns, formatters=_formatters
)
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']
)
self.assertEqual(
['affinity'],
cmd_output['policies']
'affinity',
cmd_output['policy']
)
cmd_output = json.loads(self.openstack(
@ -47,8 +47,8 @@ class ServerGroupTests(base.TestCase):
cmd_output['name']
)
self.assertEqual(
['anti-affinity'],
cmd_output['policies']
'anti-affinity',
cmd_output['policy']
)
del_output = self.openstack(
@ -60,7 +60,7 @@ class ServerGroupTests(base.TestCase):
name1 = uuid.uuid4().hex
name2 = uuid.uuid4().hex
# test server gorup show
# test server group show
cmd_output = json.loads(self.openstack(
'server group create -f json ' +
'--policy affinity ' +
@ -74,8 +74,8 @@ class ServerGroupTests(base.TestCase):
cmd_output['name']
)
self.assertEqual(
['affinity'],
cmd_output['policies']
'affinity',
cmd_output['policy']
)
cmd_output = json.loads(self.openstack(
@ -91,8 +91,8 @@ class ServerGroupTests(base.TestCase):
cmd_output['name']
)
self.assertEqual(
['anti-affinity'],
cmd_output['policies']
'anti-affinity',
cmd_output['policy']
)
# test server group list
@ -101,6 +101,6 @@ class ServerGroupTests(base.TestCase):
names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names)
self.assertIn(name2, names)
policies = [x["Policies"] for x in cmd_output]
self.assertIn(['affinity'], policies)
self.assertIn(['anti-affinity'], policies)
policies = [x["Policy"] for x in cmd_output]
self.assertIn('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 openstack.compute.v2 import flavor as _flavor
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 service
from openstack.compute.v2 import volume_attachment
@ -1290,72 +1291,6 @@ class FakeHost(object):
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):
"""Fake one or more usage."""
@ -1860,6 +1795,34 @@ class FakeVolumeAttachment(object):
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):
"""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 novaclient import api_versions
from openstack import utils as sdk_utils
from osc_lib.cli import format_columns
from osc_lib import exceptions
from osc_lib import utils
from openstackclient.compute.v2 import server_group
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):
fake_server_group = compute_fakes.FakeServerGroup.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()
fake_server_group = compute_fakes.create_one_server_group()
columns = (
'id',
@ -66,31 +34,40 @@ class TestServerGroupV264(TestServerGroup):
'name',
'policy',
'project_id',
'rules',
'user_id',
)
data = (
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.policy,
fake_server_group.project_id,
format_columns.DictColumn(fake_server_group.rules),
fake_server_group.user_id,
)
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):
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)
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 = [
'--policy', 'anti-affinity',
'affinity_group',
@ -101,18 +78,16 @@ class TestServerGroupCreate(TestServerGroup):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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,
policies=[parsed_args.policy],
policy=parsed_args.policy,
)
self.assertCountEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
def test_server_group_create_with_soft_policies(self):
self.app.client_manager.compute.api_version = api_versions.APIVersion(
'2.15')
@mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_create_with_soft_policies(self, sm_mock):
arglist = [
'--policy', 'soft-anti-affinity',
'affinity_group',
@ -123,18 +98,16 @@ class TestServerGroupCreate(TestServerGroup):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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,
policies=[parsed_args.policy],
policy=parsed_args.policy,
)
self.assertCountEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
def test_server_group_create_with_soft_policies_pre_v215(self):
self.app.client_manager.compute.api_version = api_versions.APIVersion(
'2.14')
@mock.patch.object(sdk_utils, 'supports_microversion', return_value=False)
def test_server_group_create_with_soft_policies_pre_v215(self, sm_mock):
arglist = [
'--policy', 'soft-anti-affinity',
'affinity_group',
@ -152,10 +125,8 @@ class TestServerGroupCreate(TestServerGroup):
'--os-compute-api-version 2.15 or greater is required',
str(ex))
def test_server_group_create_with_rules(self):
self.app.client_manager.compute.api_version = api_versions.APIVersion(
'2.64')
@mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_create_with_rules(self, sm_mock):
arglist = [
'--policy', 'soft-anti-affinity',
'--rule', 'max_server_per_host=2',
@ -168,19 +139,18 @@ class TestServerGroupCreate(TestServerGroup):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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,
policy=parsed_args.policy, # should be 'policy', not 'policies'
policy=parsed_args.policy,
rules=parsed_args.rules,
)
self.assertCountEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
def test_server_group_create_with_rules_pre_v264(self):
self.app.client_manager.compute.api_version = api_versions.APIVersion(
'2.63')
@mock.patch.object(
sdk_utils, 'supports_microversion', side_effect=[True, False])
def test_server_group_create_with_rules_pre_v264(self, sm_mock):
arglist = [
'--policy', 'soft-anti-affinity',
'--rule', 'max_server_per_host=2',
@ -205,9 +175,9 @@ class TestServerGroupCreate(TestServerGroup):
class TestServerGroupDelete(TestServerGroup):
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)
def test_server_group_delete(self):
@ -219,8 +189,10 @@ class TestServerGroupDelete(TestServerGroup):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.server_groups_mock.get.assert_called_once_with('affinity_group')
self.server_groups_mock.delete.assert_called_once_with(
self.sdk_client.find_server_group.assert_called_once_with(
'affinity_group'
)
self.sdk_client.delete_server_group.assert_called_once_with(
self.fake_server_group.id
)
self.assertIsNone(result)
@ -235,13 +207,15 @@ class TestServerGroupDelete(TestServerGroup):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.server_groups_mock.get.assert_any_call('affinity_group')
self.server_groups_mock.get.assert_any_call('anti_affinity_group')
self.server_groups_mock.delete.assert_called_with(
self.sdk_client.find_server_group.assert_any_call('affinity_group')
self.sdk_client.find_server_group.assert_any_call(
'anti_affinity_group'
)
self.sdk_client.delete_server_group.assert_called_with(
self.fake_server_group.id
)
self.assertEqual(2, self.server_groups_mock.get.call_count)
self.assertEqual(2, self.server_groups_mock.delete.call_count)
self.assertEqual(2, self.sdk_client.find_server_group.call_count)
self.assertEqual(2, self.sdk_client.delete_server_group.call_count)
self.assertIsNone(result)
def test_server_group_delete_no_input(self):
@ -262,25 +236,23 @@ class TestServerGroupDelete(TestServerGroup):
('server_group', ['affinity_group', 'anti_affinity_group']),
]
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,
'affinity_group')
find_mock.assert_any_call(self.server_groups_mock,
'anti_affinity_group')
self.sdk_client.find_server_group.side_effect = [
self.fake_server_group, exceptions.CommandError]
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))
self.assertEqual(2, find_mock.call_count)
self.server_groups_mock.delete.assert_called_once_with(
self.fake_server_group.id
)
self.sdk_client.find_server_group.assert_any_call('affinity_group')
self.sdk_client.find_server_group.assert_any_call(
'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):
@ -300,28 +272,67 @@ class TestServerGroupList(TestServerGroup):
'User Id',
)
list_columns_v264 = (
'ID',
'Name',
'Policy',
)
list_columns_v264_long = (
'ID',
'Name',
'Policy',
'Members',
'Project Id',
'User Id',
)
list_data = ((
TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name,
format_columns.ListColumn(TestServerGroup.fake_server_group.policies),
format_columns.ListColumn(
TestServerGroup.fake_server_group.policies
),
),)
list_data_long = ((
TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name,
format_columns.ListColumn(TestServerGroup.fake_server_group.policies),
format_columns.ListColumn(TestServerGroup.fake_server_group.members),
format_columns.ListColumn(
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.user_id,
),)
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)
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 = []
verifylist = [
('all_projects', False),
@ -332,12 +343,13 @@ class TestServerGroupList(TestServerGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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_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 = [
'--all-projects',
'--long',
@ -350,13 +362,14 @@ class TestServerGroupList(TestServerGroup):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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)
self.assertCountEqual(self.list_columns_long, columns)
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 = [
'--limit', '1',
]
@ -370,9 +383,10 @@ class TestServerGroupList(TestServerGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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 = [
'--offset', '5',
]
@ -386,51 +400,10 @@ class TestServerGroupList(TestServerGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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)
class TestServerGroupListV264(TestServerGroupV264):
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):
@mock.patch.object(sdk_utils, 'supports_microversion', return_value=True)
def test_server_group_list_v264(self, sm_mock):
arglist = []
verifylist = [
('all_projects', False),
@ -438,12 +411,13 @@ class TestServerGroupListV264(TestServerGroupV264):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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_data, tuple(data))
self.assertCountEqual(self.list_columns_v264, columns)
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 = [
'--all-projects',
'--long',
@ -454,22 +428,23 @@ class TestServerGroupListV264(TestServerGroupV264):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
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)
self.assertCountEqual(self.list_columns_long, columns)
self.assertCountEqual(self.list_data_long, tuple(data))
self.assertCountEqual(self.list_columns_v264_long, columns)
self.assertCountEqual(self.list_data_v264_long, tuple(data))
class TestServerGroupShow(TestServerGroup):
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)
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 = [
'affinity_group',
]