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()
def test_assert_list_item(self):
expected = [
['a', 'b', 'c'],
[format_columns.DictColumn({'a': 1, 'b': 2}),
format_columns.ListColumn(['x', 'y', 'z'])]
]
actual = [
['a', 'b', 'c'],
[format_columns.DictColumn({'a': 1, 'b': 2}),
format_columns.ListColumn(['x', 'y', 'z'])]
]
self.assertListItemEqual(expected, actual)
def test_assert_item_formattable_columns_vs_legacy_formatter(self):
expected = [format_columns.DictColumn({'a': 1, 'b': 2}),
format_columns.ListColumn(['x', 'y', 'z'])]
actual = [utils.format_dict({'a': 1, 'b': 2}),
utils.format_list(['x', 'y', 'z'])]
self.assertRaises(AssertionError,
self.assertItemEqual, expected, actual)
class TestQosShow(TestQos):
qos_spec = volume_fakes.FakeQos.create_one_qos()
qos_association = volume_fakes.FakeQos.create_one_qos_association()
columns = ('associations', 'consumer', 'id', 'name', 'properties')
data = (
format_columns.ListColumn([qos_association.name]),
qos_spec.consumer,
qos_spec.id,
qos_spec.name,
format_columns.DictColumn(qos_spec.specs),
)
def setUp(self):
super(TestQosShow, self).setUp()
self.qos_mock.get.return_value = self.qos_spec
self.qos_mock.get_associations.return_value = [self.qos_association]
# Get the command object to test
self.cmd = qos_specs.ShowQos(self.app, None)
def test_qos_show(self):
arglist = [self.qos_spec.id]
verifylist = [('qos_spec', self.qos_spec.id)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.qos_mock.get.assert_called_with(self.qos_spec.id)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, tuple(data))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if parsed_args.remote_id_file:
file_content = utils.read_blob_file_contents(
parsed_args.remote_id_file)
remote_ids = file_content.splitlines()
remote_ids = list(map(str.strip, remote_ids))
else:
remote_ids = (parsed_args.remote_id
if parsed_args.remote_id else None)
domain_id = None
if parsed_args.domain:
domain_id = common.find_domain(identity_client,
parsed_args.domain).id
idp = identity_client.federation.identity_providers.create(
id=parsed_args.identity_provider_id,
remote_ids=remote_ids,
description=parsed_args.description,
domain_id=domain_id,
enabled=parsed_args.enabled)
idp._info.pop('links', None)
remote_ids = format_columns.ListColumn(idp._info.pop('remote_ids', []))
idp._info['remote_ids'] = remote_ids
return zip(*sorted(idp._info.items()))
def _generate_data(ordered_dict=None, data=None):
source = ordered_dict if ordered_dict else _ipsec_site_conn
if data:
source.update(data)
return (
_ipsec_site_conn['id'],
_ipsec_site_conn['name'],
_ipsec_site_conn['peer_address'],
_ipsec_site_conn['auth_mode'],
_ipsec_site_conn['status'],
_ipsec_site_conn['tenant_id'],
format_columns.ListColumn(_ipsec_site_conn['peer_cidrs']),
_ipsec_site_conn['vpnservice_id'],
_ipsec_site_conn['ipsecpolicy_id'],
_ipsec_site_conn['ikepolicy_id'],
_ipsec_site_conn['mtu'],
_ipsec_site_conn['initiator'],
_ipsec_site_conn['admin_state_up'],
_ipsec_site_conn['description'],
_ipsec_site_conn['psk'],
_ipsec_site_conn['route_mode'],
_ipsec_site_conn['local_id'],
_ipsec_site_conn['peer_id'],
_ipsec_site_conn['local_ep_group_id'],
_ipsec_site_conn['peer_ep_group_id'],
)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
info = {}
data = compute_client.aggregates.create(
parsed_args.name,
parsed_args.zone,
)
info.update(data._info)
if parsed_args.property:
info.update(
compute_client.aggregates.set_metadata(
data,
parsed_args.property,
)._info)
# Special mapping for columns to make the output easier to read:
# 'metadata' --> 'properties'
hosts = None
properties = None
if 'hosts' in info.keys():
hosts = format_columns.ListColumn(info.pop('hosts'))
if 'metadata' in info.keys():
properties = format_columns.DictColumn(info.pop('metadata'))
info.update({
'hosts': hosts,
'properties': properties,
}, )
return zip(*sorted(info.items()))
def test_assert_item_with_formattable_columns(self):
expected = [
format_columns.DictColumn({
'a': 1,
'b': 2
}),
format_columns.ListColumn(['x', 'y', 'z'])
]
actual = [
format_columns.DictColumn({
'a': 1,
'b': 2
}),
format_columns.ListColumn(['x', 'y', 'z'])
]
self.assertItemEqual(expected, actual)
def _format_image(image):
"""Format an image to make it more consistent with OSC operations."""
info = {}
properties = {}
# the only fields we're not including is "links", "tags" and the properties
fields_to_show = [
'status', 'name', 'container_format', 'created_at', 'size',
'disk_format', 'updated_at', 'visibility', 'min_disk', 'protected',
'id', 'file', 'checksum', 'owner', 'virtual_size', 'min_ram', 'schema'
]
# split out the usual key and the properties which are top-level
for key in six.iterkeys(image):
if key in fields_to_show:
info[key] = image.get(key)
elif key == 'tags':
continue # handle this later
else:
properties[key] = image.get(key)
# format the tags if they are there
info['tags'] = format_columns.ListColumn(image.get('tags'))
# add properties back into the dictionary as a top-level key
if properties:
info['properties'] = format_columns.DictColumn(properties)
return info
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,
format_columns.ListColumn(None),
format_columns.DictColumn(self.qos_specs[1].specs),
)
self.assertCountEqual(ex_data, list(data))
class TestAggregate(compute_fakes.TestComputev2):
fake_ag = compute_fakes.FakeAggregate.create_one_aggregate()
columns = (
'availability_zone',
'hosts',
'id',
'name',
'properties',
)
data = (
fake_ag.availability_zone,
format_columns.ListColumn(fake_ag.hosts),
fake_ag.id,
fake_ag.name,
format_columns.DictColumn(fake_ag.metadata),
)
def setUp(self):
super(TestAggregate, self).setUp()
# Get a shortcut to the AggregateManager Mock
self.app.client_manager.sdk_connection = mock.Mock()
self.app.client_manager.sdk_connection.compute = mock.Mock()
self.sdk_client = self.app.client_manager.sdk_connection.compute
self.sdk_client.aggregates = mock.Mock()
self.sdk_client.find_aggregate = mock.Mock()
self.sdk_client.create_aggregate = mock.Mock()
self.sdk_client.update_aggregate = mock.Mock()
self.sdk_client.update_aggregate = mock.Mock()
self.sdk_client.set_aggregate_metadata = mock.Mock()
self.sdk_client.add_host_to_aggregate = mock.Mock()
self.sdk_client.remove_host_from_aggregate = mock.Mock()
def test_type_show_with_access(self):
arglist = [self.volume_type.id]
verifylist = [("volume_type", self.volume_type.id)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
private_type = volume_fakes.FakeVolumeType.create_one_volume_type(
attrs={'is_public': False})
type_access_list = volume_fakes.FakeTypeAccess.create_one_type_access()
with mock.patch.object(self.types_mock,
'get',
return_value=private_type):
with mock.patch.object(self.types_access_mock,
'list',
return_value=[type_access_list]):
columns, data = self.cmd.take_action(parsed_args)
self.types_mock.get.assert_called_once_with(
self.volume_type.id)
self.types_access_mock.list.assert_called_once_with(
private_type.id)
self.assertEqual(self.columns, columns)
private_type_data = (format_columns.ListColumn([
type_access_list.project_id
]), private_type.description, private_type.id, private_type.is_public,
private_type.name,
format_columns.DictColumn(
private_type.extra_specs))
self.assertCountEqual(private_type_data, data)
class TestAggregate(compute_fakes.TestComputev2):
fake_ag = compute_fakes.FakeAggregate.create_one_aggregate()
columns = (
'availability_zone',
'hosts',
'id',
'name',
'properties',
)
data = (
fake_ag.availability_zone,
format_columns.ListColumn(fake_ag.hosts),
fake_ag.id,
fake_ag.name,
format_columns.DictColumn(fake_ag.metadata),
)
def setUp(self):
super(TestAggregate, self).setUp()
# Get a shortcut to the AggregateManager Mock
self.aggregate_mock = self.app.client_manager.compute.aggregates
self.aggregate_mock.reset_mock()
class TestServerGroupV264(TestServerGroup):
fake_server_group = \
compute_fakes.FakeServerGroupV264.create_one_server_group()
columns = (
'id',
'members',
'name',
'policy',
'project_id',
'user_id',
)
data = (
fake_server_group.id,
format_columns.ListColumn(fake_server_group.members),
fake_server_group.name,
fake_server_group.policy,
fake_server_group.project_id,
fake_server_group.user_id,
)
def setUp(self):
super(TestServerGroupV264, self).setUp()
class TestAggregateList(TestAggregate):
list_columns = (
"ID",
"Name",
"Availability Zone",
)
list_columns_long = (
"ID",
"Name",
"Availability Zone",
"Properties",
"Hosts",
)
list_data = ((
TestAggregate.fake_ag.id,
TestAggregate.fake_ag.name,
TestAggregate.fake_ag.availability_zone,
), )
list_data_long = ((
TestAggregate.fake_ag.id,
TestAggregate.fake_ag.name,
TestAggregate.fake_ag.availability_zone,
format_columns.DictColumn({
key: value
for key, value in TestAggregate.fake_ag.metadata.items()
if key != 'availability_zone'
}),
format_columns.ListColumn(TestAggregate.fake_ag.hosts),
), )
def setUp(self):
super(TestAggregateList, self).setUp()
self.sdk_client.aggregates.return_value = [self.fake_ag]
self.cmd = aggregate.ListAggregate(self.app, None)
def test_aggregate_list(self):
parsed_args = self.check_parser(self.cmd, [], [])
columns, data = self.cmd.take_action(parsed_args)
self.assertEqual(self.list_columns, columns)
self.assertCountEqual(self.list_data, tuple(data))
def test_aggregate_list_with_long(self):
arglist = [
'--long',
]
vertifylist = [
('long', True),
]
parsed_args = self.check_parser(self.cmd, arglist, vertifylist)
columns, data = self.cmd.take_action(parsed_args)
self.assertEqual(self.list_columns_long, columns)
self.assertCountEqual(self.list_data_long, tuple(data))
def test_list_column(self):
list_content = [
'key1',
'key2',
]
col = format_columns.ListColumn(list_content)
self.assertEqual(list_content, col.machine_readable())
self.assertEqual("key1, key2", col.human_readable())
def image_data(self, image):
datalist = (
image['id'],
image['name'],
image['owner'],
image['protected'],
'active',
format_columns.ListColumn(image.get('tags')),
image['visibility'],
)
return datalist
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
idp = utils.find_resource(
identity_client.federation.identity_providers,
parsed_args.identity_provider,
id=parsed_args.identity_provider)
idp._info.pop('links', None)
remote_ids = format_columns.ListColumn(idp._info.pop('remote_ids', []))
idp._info['remote_ids'] = remote_ids
return zip(*sorted(idp._info.items()))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
qos_spec = utils.find_resource(volume_client.qos_specs,
parsed_args.qos_spec)
qos_associations = volume_client.qos_specs.get_associations(qos_spec)
if qos_associations:
associations = [association.name
for association in qos_associations]
qos_spec._info.update({
'associations': format_columns.ListColumn(associations)
})
qos_spec._info.update(
{'properties':
format_columns.DictColumn(qos_spec._info.pop('specs'))})
return zip(*sorted(six.iteritems(qos_spec._info)))
def get_image_data(image=None):
"""Get the image data from a faked image object.
:param image:
A FakeResource objects faking image
:return:
A tuple which may include the following values:
('image-123', 'image-foo', 'admin', False, 'public', 'bar, baz')
"""
data_list = []
if image is not None:
for x in sorted(image.keys()):
if x == 'tags':
# The 'tags' should be format_list
data_list.append(
format_columns.ListColumn(getattr(image, x)))
else:
data_list.append(getattr(image, x))
return tuple(data_list)
def test_qos_show(self):
arglist = [self.qos_spec.id]
verifylist = [('qos_spec', self.qos_spec.id)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.qos_mock.get.assert_called_with(self.qos_spec.id)
collist = ('associations', 'consumer', 'id', 'name', 'properties')
self.assertEqual(collist, columns)
datalist = (
format_columns.ListColumn([self.qos_association.name]),
self.qos_spec.consumer,
self.qos_spec.id,
self.qos_spec.name,
format_columns.DictColumn(self.qos_spec.specs),
)
self.assertItemEqual(datalist, tuple(data))
class TestAggregateShow(TestAggregate):
columns = (
'availability_zone',
'hosts',
'id',
'name',
'properties',
)
data = (
TestAggregate.fake_ag.availability_zone,
format_columns.ListColumn(TestAggregate.fake_ag.hosts),
TestAggregate.fake_ag.id,
TestAggregate.fake_ag.name,
format_columns.DictColumn({
key: value
for key, value in TestAggregate.fake_ag.metadata.items()
if key != 'availability_zone'
}),
)
def setUp(self):
super(TestAggregateShow, self).setUp()
self.sdk_client.find_aggregate.return_value = self.fake_ag
self.cmd = aggregate.ShowAggregate(self.app, None)
def test_aggregate_show(self):
arglist = [
'ag1',
]
verifylist = [
('aggregate', 'ag1'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.sdk_client.find_aggregate.assert_called_once_with(
parsed_args.aggregate, ignore_missing=False)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, tuple(data))
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
aggregate = utils.find_resource(
compute_client.aggregates,
parsed_args.aggregate,
)
data = compute_client.aggregates.add_host(aggregate, parsed_args.host)
info = {}
info.update(data._info)
# Special mapping for columns to make the output easier to read:
# 'metadata' --> 'properties'
info.update(
{
'hosts': format_columns.ListColumn(info.pop('hosts')),
'properties': format_columns.DictColumn(info.pop('metadata')),
}, )
return zip(*sorted(info.items()))
def get_volume_data(volume=None):
"""Get the volume data from a faked volume object.
:param volume:
A FakeResource objects faking volume
:return
A tuple which may include the following values:
('ce26708d', 'fake_volume', 'fake description', 'available',
20, 'fake_lvmdriver-1', "Alpha='a', Beta='b', Gamma='g'",
1, 'nova', [{'device': '/dev/ice', 'server_id': '1233'}])
"""
data_list = []
if volume is not None:
for x in sorted(volume.keys()):
if x == 'tags':
# The 'tags' should be format_list
data_list.append(
format_columns.ListColumn(volume.info.get(x)))
else:
data_list.append(volume.info.get(x))
return tuple(data_list)
def _format_image(image, human_readable=False):
"""Format an image to make it more consistent with OSC operations."""
info = {}
properties = {}
# the only fields we're not including is "links", "tags" and the properties
fields_to_show = [
'status', 'name', 'container_format', 'created_at', 'size',
'disk_format', 'updated_at', 'visibility', 'min_disk', 'protected',
'id', 'file', 'checksum', 'owner', 'virtual_size', 'min_ram', 'schema'
]
# TODO(gtema/anybody): actually it should be possible to drop this method,
# since SDK already delivers a proper object
image = image.to_dict(ignore_none=True, original_names=True)
# split out the usual key and the properties which are top-level
for key in image:
if key in fields_to_show:
info[key] = image.get(key)
elif key == 'tags':
continue # handle this later
elif key == 'properties':
# NOTE(gtema): flatten content of properties
properties.update(image.get(key))
elif key != 'location':
properties[key] = image.get(key)
if human_readable:
info['size'] = utils.format_size(image['size'])
# format the tags if they are there
info['tags'] = format_columns.ListColumn(image.get('tags'))
# add properties back into the dictionary as a top-level key
if properties:
info['properties'] = format_columns.DictColumn(properties)
return info
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
volume_type = utils.find_resource(volume_client.volume_types,
parsed_args.volume_type)
properties = format_columns.DictColumn(
volume_type._info.pop('extra_specs', {}))
volume_type._info.update({'properties': properties})
access_project_ids = None
if not volume_type.is_public:
try:
volume_type_access = volume_client.volume_type_access.list(
volume_type.id)
project_ids = [
utils.get_field(item, 'project_id')
for item in volume_type_access
]
# TODO(Rui Chen): This format list case can be removed after
# patch https://review.opendev.org/#/c/330223/ merged.
access_project_ids = format_columns.ListColumn(project_ids)
except Exception as e:
msg = _('Failed to get access project list for volume type '
'%(type)s: %(e)s')
LOG.error(msg % {'type': volume_type.id, 'e': e})
volume_type._info.update({'access_project_ids': access_project_ids})
if parsed_args.encryption_type:
# show encryption type information for this volume type
try:
encryption = volume_client.volume_encryption_types.get(
volume_type.id)
encryption._info.pop("volume_type_id", None)
volume_type._info.update({
'encryption':
format_columns.DictColumn(encryption._info)
})
except Exception as e:
LOG.error(
_("Failed to display the encryption information "
"of this volume type: %s"), e)
volume_type._info.pop("os-volume-type-access:is_public", None)
return zip(*sorted(six.iteritems(volume_type._info)))
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
data = utils.find_resource(
compute_client.aggregates,
parsed_args.aggregate,
)
# Remove availability_zone from metadata because Nova doesn't
if 'availability_zone' in data.metadata:
data.metadata.pop('availability_zone')
# Special mapping for columns to make the output easier to read:
# 'metadata' --> 'properties'
data._info.update(
{
'hosts':
format_columns.ListColumn(data._info.pop('hosts')),
'properties':
format_columns.DictColumn(data._info.pop('metadata')),
}, )
info = {}
info.update(data._info)
return zip(*sorted(info.items()))
def _update_expect_response(self, request, response):
"""Set expected request and response
:param request
A dictionary of request body(dict of verifylist)
:param response
A OrderedDict of request body
"""
# Update response body
self.neutronclient.create_ipsec_site_connection.return_value = \
{self.res: dict(response)}
osc_utils.find_project.return_value.id = response['tenant_id']
# Update response(finally returns 'data')
self.data = _generate_data(ordered_dict=response)
self.ordered_data = (
response['auth_mode'],
response['description'],
response['id'],
response['ikepolicy_id'],
response['ipsecpolicy_id'],
response['initiator'],
response['local_ep_group_id'],
response['local_id'],
response['mtu'],
response['name'],
response['peer_address'],
format_columns.ListColumn(response['peer_cidrs']),
response['peer_ep_group_id'],
response['peer_id'],
response['psk'],
response['tenant_id'],
response['route_mode'],
response['admin_state_up'],
response['status'],
response['vpnservice_id'],
)
'id': token_id,
'project_id': project_id,
'user_id': user_id,
}
TOKEN_WITH_DOMAIN_ID = {
'expires': token_expires,
'id': token_id,
'domain_id': domain_id,
'user_id': user_id,
}
idp_id = 'test_idp'
idp_description = 'super exciting IdP description'
idp_remote_ids = ['entity1', 'entity2']
formatted_idp_remote_ids = format_columns.ListColumn(idp_remote_ids)
IDENTITY_PROVIDER = {
'id': idp_id,
'remote_ids': idp_remote_ids,
'enabled': True,
'description': idp_description,
'domain_id': domain_id,
}
protocol_id = 'protocol'
mapping_id = 'test_mapping'
mapping_id_updated = 'prod_mapping'
sp_id = 'BETA'
def setUp(self):
super(TestIPsecSiteConn, self).setUp()
def _mock_ipsec_site_conn(*args, **kwargs):
return {'id': args[1]}
self.neutronclient.find_resource.side_effect = mock.Mock(
side_effect=_mock_ipsec_site_conn)
osc_utils.find_project = mock.Mock()
osc_utils.find_project.id = _ipsec_site_conn['tenant_id']
self.res = 'ipsec_site_connection'
self.res_plural = 'ipsec_site_connections'
self.resource = _ipsec_site_conn
self.headers = ('ID', 'Name', 'Peer Address',
'Authentication Algorithm', 'Status', 'Project',
'Peer CIDRs', 'VPN Service', 'IPSec Policy',
'IKE Policy', 'MTU', 'Initiator', 'State',
'Description', 'Pre-shared Key', 'Route Mode',
'Local ID', 'Peer ID', 'Local Endpoint Group ID',
'Peer Endpoint Group ID')
self.data = _generate_data()
self.ordered_headers = (
'Authentication Algorithm',
'Description',
'ID',
'IKE Policy',
'IPSec Policy',
'Initiator',
'Local Endpoint Group ID',
'Local ID',
'MTU',
'Name',
'Peer Address',
'Peer CIDRs',
'Peer Endpoint Group ID',
'Peer ID',
'Pre-shared Key',
'Project',
'Route Mode',
'State',
'Status',
'VPN Service',
)
self.ordered_data = (
_ipsec_site_conn['auth_mode'],
_ipsec_site_conn['description'],
_ipsec_site_conn['id'],
_ipsec_site_conn['ikepolicy_id'],
_ipsec_site_conn['ipsecpolicy_id'],
_ipsec_site_conn['initiator'],
_ipsec_site_conn['local_ep_group_id'],
_ipsec_site_conn['local_id'],
_ipsec_site_conn['mtu'],
_ipsec_site_conn['name'],
_ipsec_site_conn['peer_address'],
format_columns.ListColumn(_ipsec_site_conn['peer_cidrs']),
_ipsec_site_conn['peer_ep_group_id'],
_ipsec_site_conn['peer_id'],
_ipsec_site_conn['psk'],
_ipsec_site_conn['tenant_id'],
_ipsec_site_conn['route_mode'],
_ipsec_site_conn['admin_state_up'],
_ipsec_site_conn['status'],
_ipsec_site_conn['vpnservice_id'],
)
