def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.version:
data = client.plugins.get_version_details(
parsed_args.plugin, parsed_args.version).to_dict()
processes = data.pop('node_processes')
for k, v in processes.items():
processes[k] = osc_utils.format_list(v)
data['required_image_tags'] = osc_utils.format_list(
data['required_image_tags'])
data = utils.prepare_data(
data, ['required_image_tags', 'name', 'description', 'title'])
data = zip(*sorted(data.items()) + [('', ''), (
'Service:', 'Available processes:'), ('', '')] + sorted(
processes.items()))
else:
data = client.plugins.get(parsed_args.plugin).to_dict()
data['versions'] = osc_utils.format_list(data['versions'])
data = utils.prepare_data(
data, ['versions', 'name', 'description', 'title'])
data = self.dict2columns(data)
return data
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.plugin_version:
data = client.plugins.get_version_details(
parsed_args.plugin, parsed_args.plugin_version).to_dict()
processes = data.pop('node_processes')
for k, v in processes.items():
processes[k] = osc_utils.format_list(v)
data['required_image_tags'] = osc_utils.format_list(
data['required_image_tags'])
data = utils.prepare_data(
data, ['required_image_tags', 'name', 'description', 'title'])
data = zip(
*sorted(data.items()) +
[('', ''), ('Service:', 'Available processes:'), ('', '')] +
sorted(processes.items()))
else:
data = client.plugins.get(parsed_args.plugin).to_dict()
data['versions'] = osc_utils.format_list(data['versions'])
data = utils.prepare_data(
data, ['versions', 'name', 'description', 'title'])
data = self.dict2columns(data)
return data
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,
utils.format_list(fake_server_group.members),
fake_server_group.name,
utils.format_list(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 _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'] = utils.format_list(image.get('tags'))
# add properties back into the dictionary as a top-level key
if properties:
info['properties'] = utils.format_dict(properties)
return info
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'] = utils.format_list(image.get('tags'))
# add properties back into the dictionary as a top-level key
if properties:
info['properties'] = utils.format_dict(properties)
return info
class TestShowNetwork(TestNetwork):
# The network to set.
_network = network_fakes.FakeNetwork.create_one_network()
columns = (
'admin_state_up',
'id',
'name',
'project_id',
'router_external',
'status',
'subnets',
)
data = (
network._format_admin_state(_network.admin_state_up),
_network.id,
_network.name,
_network.project_id,
network._format_router_external(_network.router_external),
_network.status,
utils.format_list(_network.subnets),
)
def setUp(self):
super(TestShowNetwork, self).setUp()
self.network.find_network = mock.Mock(return_value=self._network)
# Get the command object to test
self.cmd = network.ShowNetwork(self.app, self.namespace)
def test_show_no_options(self):
arglist = []
verifylist = []
try:
# Missing required args should bail here
self.check_parser(self.cmd, arglist, verifylist)
except tests_utils.ParserException:
pass
def test_show_all_options(self):
arglist = [
self._network.name,
]
verifylist = [
('identifier', self._network.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_network.assert_called_with(self._network.name,
ignore_missing=False)
self.assertEqual(tuple(self.columns), columns)
self.assertEqual(list(self.data), list(data))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
data = client.plugins.get(parsed_args.plugin).to_dict()
data["versions"] = osc_utils.format_list(data["versions"])
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
data = client.plugins.get(parsed_args.plugin).to_dict()
data['versions'] = utils.format_list(data['versions'])
return self.dict2columns(data)
def _format_ngt_output(data):
data['node_processes'] = osc_utils.format_list(data['node_processes'])
data['version'] = data.pop('hadoop_version')
if data['volumes_per_node'] == 0:
del data['volume_local_to_instance']
del data['volume_mount_prefix']
del data['volume_type'],
del data['volumes_availability_zone']
del data['volumes_size']
def _format_ngt_output(data):
data['node_processes'] = osc_utils.format_list(data['node_processes'])
data['version'] = data.pop('hadoop_version')
if data['volumes_per_node'] == 0:
del data['volume_local_to_instance']
del data['volume_mount_prefix']
del data['volume_type'],
del data['volumes_availability_zone']
del data['volumes_size']
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)
idp._info.pop('links', None)
remote_ids = utils.format_list(idp._info.pop('remote_ids', []))
idp._info['remote_ids'] = remote_ids
return zip(*sorted(six.iteritems(idp._info)))
class TestShowIPAvailability(TestIPAvailability):
_ip_availability = \
network_fakes.FakeIPAvailability.create_one_ip_availability()
columns = (
'network_id',
'network_name',
'project_id',
'subnet_ip_availability',
'total_ips',
'used_ips',
)
data = (
_ip_availability.network_id,
_ip_availability.network_name,
_ip_availability.tenant_id,
osc_utils.format_list(
_ip_availability.subnet_ip_availability),
_ip_availability.total_ips,
_ip_availability.used_ips,
)
def setUp(self):
super(TestShowIPAvailability, self).setUp()
self.network.find_network_ip_availability = mock.Mock(
return_value=self._ip_availability)
# Get the command object to test
self.cmd = ip_availability.ShowIPAvailability(
self.app, self.namespace)
def test_show_no_option(self):
arglist = []
verifylist = []
self.assertRaises(tests_utils.ParserException,
self.check_parser, self.cmd, arglist, verifylist)
def test_show_all_options(self):
arglist = [
self._ip_availability.network_name,
]
verifylist = [
('network', self._ip_availability.network_name)
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_network_ip_availability.assert_called_once_with(
self._ip_availability.network_name,
ignore_missing=False)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(
client.images, parsed_args.image).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
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": utils.format_list(associations)})
qos_spec._info.update({"specs": utils.format_dict(qos_spec.specs)})
return zip(*sorted(six.iteritems(qos_spec._info)))
def image_data(self, image):
datalist = (
image['id'],
image['name'],
image['owner'],
image['protected'],
'active',
common_utils.format_list(image.get('tags')),
image['visibility'],
)
return datalist
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(
client.images, parsed_args.image).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
fields = ['name', 'id', 'username', 'tags', 'status', 'description']
data = utils.prepare_data(data, fields)
return self.dict2columns(data)
def _get_common_cols_data(self, fake_port):
columns = (
'admin_state_up',
'allowed_address_pairs',
'binding_host_id',
'binding_profile',
'binding_vif_details',
'binding_vif_type',
'binding_vnic_type',
'device_id',
'device_owner',
'dns_assignment',
'dns_name',
'extra_dhcp_opts',
'fixed_ips',
'id',
'mac_address',
'name',
'network_id',
'port_security_enabled',
'project_id',
'security_groups',
'status',
)
data = (
port._format_admin_state(fake_port.admin_state_up),
utils.format_list_of_dicts(fake_port.allowed_address_pairs),
fake_port.binding_host_id,
utils.format_dict(fake_port.binding_profile),
utils.format_dict(fake_port.binding_vif_details),
fake_port.binding_vif_type,
fake_port.binding_vnic_type,
fake_port.device_id,
fake_port.device_owner,
utils.format_list_of_dicts(fake_port.dns_assignment),
fake_port.dns_name,
utils.format_list_of_dicts(fake_port.extra_dhcp_opts),
utils.format_list_of_dicts(fake_port.fixed_ips),
fake_port.id,
fake_port.mac_address,
fake_port.name,
fake_port.network_id,
fake_port.port_security_enabled,
fake_port.project_id,
utils.format_list(fake_port.security_groups),
fake_port.status,
)
return columns, data
def _get_common_cols_data(self, fake_port):
columns = (
'admin_state_up',
'allowed_address_pairs',
'binding_host_id',
'binding_profile',
'binding_vif_details',
'binding_vif_type',
'binding_vnic_type',
'device_id',
'device_owner',
'dns_assignment',
'dns_name',
'extra_dhcp_opts',
'fixed_ips',
'id',
'mac_address',
'name',
'network_id',
'port_security_enabled',
'project_id',
'security_groups',
'status',
)
data = (
port._format_admin_state(fake_port.admin_state_up),
utils.format_list_of_dicts(fake_port.allowed_address_pairs),
fake_port.binding_host_id,
utils.format_dict(fake_port.binding_profile),
utils.format_dict(fake_port.binding_vif_details),
fake_port.binding_vif_type,
fake_port.binding_vnic_type,
fake_port.device_id,
fake_port.device_owner,
utils.format_list_of_dicts(fake_port.dns_assignment),
fake_port.dns_name,
utils.format_list_of_dicts(fake_port.extra_dhcp_opts),
utils.format_list_of_dicts(fake_port.fixed_ips),
fake_port.id,
fake_port.mac_address,
fake_port.name,
fake_port.network_id,
fake_port.port_security_enabled,
fake_port.project_id,
utils.format_list(fake_port.security_groups),
fake_port.status,
)
return columns, data
def _prep_network_detail(net):
"""Prepare network object for output"""
if 'subnets' in net:
net['subnets'] = utils.format_list(net['subnets'])
if 'admin_state_up' in net:
net['state'] = 'UP' if net['admin_state_up'] else 'DOWN'
net.pop('admin_state_up')
if 'router:external' in net:
net['router_type'] = 'External' if net['router:external'] \
else 'Internal'
net.pop('router:external')
if 'tenant_id' in net:
net['project_id'] = net.pop('tenant_id')
return net
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
description = parsed_args.description or ''
data = client.images.update_image(
parsed_args.image, user_name=parsed_args.username,
desc=description).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
fields = ['name', 'id', 'username', 'tags', 'status', 'description']
data = utils.prepare_data(data, fields)
return self.dict2columns(data)
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': utils.format_list(associations)})
qos_spec._info.update({'specs': utils.format_dict(qos_spec.specs)})
return zip(*sorted(six.iteritems(qos_spec._info)))
def _prep_network_detail(net):
"""Prepare network object for output"""
if 'subnets' in net:
net['subnets'] = utils.format_list(net['subnets'])
if 'admin_state_up' in net:
net['state'] = 'UP' if net['admin_state_up'] else 'DOWN'
net.pop('admin_state_up')
if 'router:external' in net:
net['router_type'] = 'External' if net['router:external'] \
else 'Internal'
net.pop('router:external')
if 'tenant_id' in net:
net['project_id'] = net.pop('tenant_id')
return net
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
volume_client = self.app.client_manager.volume
qos_specs = utils.find_resource(volume_client.qos_specs,
parsed_args.qos_specs)
qos_associations = volume_client.qos_specs.get_associations(qos_specs)
if qos_associations:
associations = [association.name
for association in qos_associations]
qos_specs._info.update({
'associations': utils.format_list(associations)
})
qos_specs._info.update({'specs': utils.format_dict(qos_specs.specs)})
return zip(*sorted(six.iteritems(qos_specs._info)))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
image_client = self.app.client_manager.image
image_id = osc_utils.find_resource(
image_client.images, parsed_args.image).id
data = client.images.update_image(
image_id, user_name=parsed_args.username,
desc=parsed_args.description).image
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.data_processing
image = utils.get_resource(client.images, parsed_args.image)
if parsed_args.all:
data = client.images.update_tags(image.id, []).to_dict()
else:
parsed_args.tags = parsed_args.tags or []
new_tags = list(set(image.tags) - set(parsed_args.tags))
data = client.images.update_tags(image.id, new_tags).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def get_parser(self, prog_name):
parser = super(CreateQos, self).get_parser(prog_name)
parser.add_argument("name", metavar="<name>", help="New QoS specification name")
consumer_choices = ["front-end", "back-end", "both"]
parser.add_argument(
"--consumer",
metavar="<consumer>",
choices=consumer_choices,
default="both",
help="Consumer of the QoS. Valid consumers: %s "
"(defaults to 'both')" % utils.format_list(consumer_choices),
)
parser.add_argument(
"--property",
metavar="<key=value>",
action=parseractions.KeyValueAction,
help="Set a QoS specification property " "(repeat option to set multiple properties)",
)
return parser
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(FakeImage.get_image_info(image).keys()):
if x == 'tags':
# The 'tags' should be format_list
data_list.append(
common_utils.format_list(getattr(image, x)))
else:
data_list.append(getattr(image, x))
return tuple(data_list)
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(FakeImage.get_image_info(image).keys()):
if x == 'tags':
# The 'tags' should be format_list
data_list.append(
common_utils.format_list(getattr(image, x)))
else:
data_list.append(getattr(image, x))
return tuple(data_list)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
info = {}
info.update(
utils.find_resource(
compute_client.security_groups,
parsed_args.group,
)._info)
rules = []
for r in info['rules']:
rules.append(utils.format_dict(_xform_security_group_rule(r)))
# Format rules into a list of strings
info.update({'rules': utils.format_list(rules, separator='\n')})
# Map 'tenant_id' column to 'project_id'
info.update({'project_id': info.pop('tenant_id')})
return zip(*sorted(six.iteritems(info)))
def test_image_list_long_option(self):
arglist = [
'--long',
]
verifylist = [
('long', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# In base command class Lister in cliff, abstract method take_action()
# returns a tuple containing the column names and an iterable
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.api_mock.image_list.assert_called_with()
collist = (
'ID',
'Name',
'Disk Format',
'Container Format',
'Size',
'Status',
'Visibility',
'Protected',
'Project',
'Tags',
)
self.assertEqual(collist, columns)
datalist = ((
self._image.id,
self._image.name,
'',
'',
'',
'',
self._image.visibility,
self._image.protected,
self._image.owner,
common_utils.format_list(self._image.tags),
), )
self.assertEqual(datalist, tuple(data))
def test_image_list_long_option(self):
arglist = [
'--long',
]
verifylist = [
('long', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# In base command class Lister in cliff, abstract method take_action()
# returns a tuple containing the column names and an iterable
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.api_mock.image_list.assert_called_with()
collist = (
'ID',
'Name',
'Disk Format',
'Container Format',
'Size',
'Status',
'Visibility',
'Protected',
'Project',
'Tags',
)
self.assertEqual(collist, columns)
datalist = ((
self._image.id,
self._image.name,
'',
'',
'',
'',
self._image.visibility,
self._image.protected,
self._image.owner,
common_utils.format_list(self._image.tags),
), )
self.assertEqual(datalist, 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)
idp = identity_client.federation.identity_providers.create(
id=parsed_args.identity_provider_id,
remote_ids=remote_ids,
description=parsed_args.description,
enabled=parsed_args.enabled)
idp._info.pop('links', None)
remote_ids = utils.format_list(idp._info.pop('remote_ids', []))
idp._info['remote_ids'] = remote_ids
return zip(*sorted(six.iteritems(idp._info)))
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(
common_utils.format_list(volume.info.get(x)))
else:
data_list.append(volume.info.get(x))
return tuple(data_list)
def take_action(self, parsed_args):
cm = self.app.command_manager
groups = cm.get_command_groups()
groups = sorted(groups)
columns = ('Command Group', 'Commands')
commands = []
for group in groups:
command_names = cm.get_command_names(group)
command_names = sorted(command_names)
if command_names != []:
# TODO(bapalm): Fix this when cliff properly supports
# handling the detection rather than using the hard-code below.
if parsed_args.formatter == 'table':
command_names = utils.format_list(command_names, "\n")
commands.append((group, command_names))
return (columns, commands)
def take_action(self, parsed_args):
cm = self.app.command_manager
groups = cm.get_command_groups()
groups = sorted(groups)
columns = ('Command Group', 'Commands')
commands = []
for group in groups:
command_names = cm.get_command_names(group)
command_names = sorted(command_names)
if command_names != []:
# TODO(bapalm): Fix this when cliff properly supports
# handling the detection rather than using the hard-code below.
if parsed_args.formatter == 'table':
command_names = utils.format_list(command_names, "\n")
commands.append((group, command_names))
return (columns, commands)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
info = {}
info.update(utils.find_resource(
compute_client.security_groups,
parsed_args.group,
)._info)
rules = []
for r in info['rules']:
rules.append(utils.format_dict(_xform_security_group_rule(r)))
# Format rules into a list of strings
info.update(
{'rules': utils.format_list(rules, separator='\n')}
)
# Map 'tenant_id' column to 'project_id'
info.update(
{'project_id': info.pop('tenant_id')}
)
return zip(*sorted(six.iteritems(info)))
def get_parser(self, prog_name):
parser = super(CreateQos, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help='New QoS specification name',
)
consumer_choices = ['front-end', 'back-end', 'both']
parser.add_argument('--consumer',
metavar='<consumer>',
choices=consumer_choices,
default='both',
help='Consumer of the QoS. Valid consumers: %s '
"(defaults to 'both')" %
utils.format_list(consumer_choices))
parser.add_argument(
'--property',
metavar='<key=value>',
action=parseractions.KeyValueAction,
help='Set a QoS specification property '
'(repeat option to set multiple properties)',
)
return parser
def get_parser(self, prog_name):
parser = super(CreateQos, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help='New QoS specification name',
)
consumer_choices = ['front-end', 'back-end', 'both']
parser.add_argument(
'--consumer',
metavar='<consumer>',
choices=consumer_choices,
default='both',
help='Consumer of the QoS. Valid consumers: %s '
"(defaults to 'both')" % utils.format_list(consumer_choices)
)
parser.add_argument(
'--property',
metavar='<key=value>',
action=parseractions.KeyValueAction,
help='Set a QoS specification property '
'(repeat option to set multiple properties)',
)
return parser
class TestCreateNetworkIdentityV3(TestNetwork):
# The new network created.
_network = network_fakes.FakeNetwork.create_one_network(
attrs={'tenant_id': identity_fakes_v3.project_id})
columns = (
'admin_state_up',
'id',
'name',
'project_id',
'router_external',
'status',
'subnets',
)
data = (
network._format_admin_state(_network.admin_state_up),
_network.id,
_network.name,
_network.project_id,
network._format_router_external(_network.router_external),
_network.status,
utils.format_list(_network.subnets),
)
def setUp(self):
super(TestCreateNetworkIdentityV3, self).setUp()
self.network.create_network = mock.Mock(return_value=self._network)
# Get the command object to test
self.cmd = network.CreateNetwork(self.app, self.namespace)
# Set identity client v3. And get a shortcut to Identity client.
identity_client = identity_fakes_v3.FakeIdentityv3Client(
endpoint=fakes.AUTH_URL,
token=fakes.AUTH_TOKEN,
)
self.app.client_manager.identity = identity_client
self.identity = self.app.client_manager.identity
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.identity.projects
self.projects_mock.get.return_value = fakes.FakeResource(
None,
copy.deepcopy(identity_fakes_v3.PROJECT),
loaded=True,
)
# Get a shortcut to the DomainManager Mock
self.domains_mock = self.identity.domains
self.domains_mock.get.return_value = fakes.FakeResource(
None,
copy.deepcopy(identity_fakes_v3.DOMAIN),
loaded=True,
)
def test_create_no_options(self):
arglist = []
verifylist = []
try:
# Missing required args should bail here
self.check_parser(self.cmd, arglist, verifylist)
except tests_utils.ParserException:
pass
def test_create_default_options(self):
arglist = [
self._network.name,
]
verifylist = [
('name', self._network.name),
('admin_state', True),
('shared', None),
('project', None),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_network.assert_called_with(
**{
'admin_state_up': True,
'name': self._network.name,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def test_create_all_options(self):
arglist = [
"--disable",
"--share",
"--project",
identity_fakes_v3.project_name,
"--project-domain",
identity_fakes_v3.domain_name,
self._network.name,
]
verifylist = [
('admin_state', False),
('shared', True),
('project', identity_fakes_v3.project_name),
('project_domain', identity_fakes_v3.domain_name),
('name', self._network.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.network.create_network.assert_called_with(
**{
'admin_state_up': False,
'name': self._network.name,
'shared': True,
'tenant_id': identity_fakes_v3.project_id,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def test_create_other_options(self):
arglist = [
"--enable",
"--no-share",
self._network.name,
]
verifylist = [
('admin_state', True),
('shared', False),
('name', self._network.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_network.assert_called_with(**{
'admin_state_up': True,
'name': self._network.name,
'shared': False,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def test_format_list(self):
expected = "a, b, c"
self.assertEqual(expected, utils.format_list(["a", "b", "c"]))
self.assertEqual(expected, utils.format_list(["c", "b", "a"]))
def filters(data):
if 'subnets' in data:
data['subnets'] = utils.format_list(data['subnets'])
return data
def _format_compute_security_group_rules(sg_rules):
rules = []
for sg_rule in sg_rules:
rules.append(_format_compute_security_group_rule(sg_rule))
return utils.format_list(rules, separator='\n')
class TestServerGroupList(TestServerGroup):
list_columns = (
'ID',
'Name',
'Policies',
)
list_columns_long = (
'ID',
'Name',
'Policies',
'Members',
'Project Id',
'User Id',
)
list_data = ((
TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name,
utils.format_list(TestServerGroup.fake_server_group.policies),
),)
list_data_long = ((
TestServerGroup.fake_server_group.id,
TestServerGroup.fake_server_group.name,
utils.format_list(TestServerGroup.fake_server_group.policies),
utils.format_list(TestServerGroup.fake_server_group.members),
TestServerGroup.fake_server_group.project_id,
TestServerGroup.fake_server_group.user_id,
),)
def setUp(self):
super(TestServerGroupList, self).setUp()
self.server_groups_mock.list.return_value = [self.fake_server_group]
self.cmd = server_group.ListServerGroup(self.app, None)
def test_server_group_list(self):
arglist = []
verifylist = [
('all_projects', False),
('long', False),
]
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(False)
self.assertEqual(self.list_columns, columns)
self.assertEqual(self.list_data, tuple(data))
def test_server_group_list_with_all_projects_and_long(self):
arglist = [
'--all-projects',
'--long',
]
verifylist = [
('all_projects', True),
('long', True),
]
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(True)
self.assertEqual(self.list_columns_long, columns)
self.assertEqual(self.list_data_long, tuple(data))
def _format_ct_output(data):
data['version'] = data.pop('hadoop_version')
data['node_groups'] = _format_node_groups_list(data['node_groups'])
data['anti_affinity'] = osc_utils.format_list(data['anti_affinity'])
class TestShowSubnet(TestSubnet):
# The subnets to be shown
_subnet = network_fakes.FakeSubnet.create_one_subnet()
columns = (
'allocation_pools',
'cidr',
'dns_nameservers',
'enable_dhcp',
'gateway_ip',
'host_routes',
'id',
'ip_version',
'ipv6_address_mode',
'ipv6_ra_mode',
'name',
'network_id',
'project_id',
'subnetpool_id',
)
data = (
subnet_v2._format_allocation_pools(_subnet.allocation_pools),
_subnet.cidr,
utils.format_list(_subnet.dns_nameservers),
_subnet.enable_dhcp,
_subnet.gateway_ip,
utils.format_list(_subnet.host_routes),
_subnet.id,
_subnet.ip_version,
_subnet.ipv6_address_mode,
_subnet.ipv6_ra_mode,
_subnet.name,
_subnet.network_id,
_subnet.tenant_id,
_subnet.subnetpool_id,
)
def setUp(self):
super(TestShowSubnet, self).setUp()
# Get the command object to test
self.cmd = subnet_v2.ShowSubnet(self.app, self.namespace)
self.network.find_subnet = mock.Mock(return_value=self._subnet)
def test_show_no_options(self):
arglist = []
verifylist = []
# Testing that a call without the required argument will fail and
# throw a "ParserExecption"
self.assertRaises(tests_utils.ParserException,
self.check_parser, self.cmd, arglist, verifylist)
def test_show_all_options(self):
arglist = [
self._subnet.name,
]
verifylist = [
('subnet', self._subnet.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_subnet.assert_called_with(self._subnet.name,
ignore_missing=False)
self.assertEqual(self.columns, columns)
self.assertEqual(list(self.data), list(data))
def test_format_list(self):
expected = 'a, b, c'
self.assertEqual(expected, utils.format_list(['a', 'b', 'c']))
self.assertEqual(expected, utils.format_list(['c', 'b', 'a']))
class TestListNetwork(TestNetwork):
# The networks going to be listed up.
_network = network_fakes.FakeNetwork.create_networks(count=3)
columns = (
'ID',
'Name',
'Subnets',
)
columns_long = (
'ID',
'Name',
'Status',
'Project',
'State',
'Shared',
'Subnets',
'Network Type',
'Router Type',
)
data = []
for net in _network:
data.append((
net.id,
net.name,
utils.format_list(net.subnets),
))
data_long = []
for net in _network:
data_long.append((
net.id,
net.name,
net.status,
net.project_id,
network._format_admin_state(net.admin_state_up),
net.shared,
utils.format_list(net.subnets),
net.provider_network_type,
network._format_router_external(net.router_external),
))
def setUp(self):
super(TestListNetwork, self).setUp()
# Get the command object to test
self.cmd = network.ListNetwork(self.app, self.namespace)
self.network.networks = mock.Mock(return_value=self._network)
def test_network_list_no_options(self):
arglist = []
verifylist = [
('external', False),
('long', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_list_external(self):
arglist = [
'--external',
]
verifylist = [
('external', True),
('long', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_with(**{'router:external': True})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_network_list_long(self):
arglist = [
'--long',
]
verifylist = [
('long', True),
('external', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
class TestListSubnet(TestSubnet):
# The subnets going to be listed up.
_subnet = network_fakes.FakeSubnet.create_subnets(count=3)
columns = (
'ID',
'Name',
'Network',
'Subnet',
)
columns_long = columns + (
'Project',
'DHCP',
'Name Servers',
'Allocation Pools',
'Host Routes',
'IP Version',
'Gateway',
)
data = []
for subnet in _subnet:
data.append((
subnet.id,
subnet.name,
subnet.network_id,
subnet.cidr,
))
data_long = []
for subnet in _subnet:
data_long.append((
subnet.id,
subnet.name,
subnet.network_id,
subnet.cidr,
subnet.tenant_id,
subnet.enable_dhcp,
utils.format_list(subnet.dns_nameservers),
subnet_v2._format_allocation_pools(subnet.allocation_pools),
utils.format_list(subnet.host_routes),
subnet.ip_version,
subnet.gateway_ip,
))
def setUp(self):
super(TestListSubnet, self).setUp()
# Get the command object to test
self.cmd = subnet_v2.ListSubnet(self.app, self.namespace)
self.network.subnets = mock.Mock(return_value=self._subnet)
def test_subnet_list_no_options(self):
arglist = []
verifylist = [
('long', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.subnets.assert_called_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_subnet_list_long(self):
arglist = [
'--long',
]
verifylist = [
('long', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.subnets.assert_called_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
class TestShowRouter(TestRouter):
# The router to set.
_router = network_fakes.FakeRouter.create_one_router()
columns = (
'admin_state_up',
'availability_zone_hints',
'availability_zones',
'distributed',
'external_gateway_info',
'ha',
'id',
'name',
'project_id',
'routes',
'status',
)
data = (
router._format_admin_state(_router.admin_state_up),
osc_utils.format_list(_router.availability_zone_hints),
osc_utils.format_list(_router.availability_zones),
_router.distributed,
router._format_external_gateway_info(_router.external_gateway_info),
_router.ha,
_router.id,
_router.name,
_router.tenant_id,
_router.routes,
_router.status,
)
def setUp(self):
super(TestShowRouter, self).setUp()
self.network.find_router = mock.Mock(return_value=self._router)
# Get the command object to test
self.cmd = router.ShowRouter(self.app, self.namespace)
def test_show_no_options(self):
arglist = []
verifylist = []
# Missing required args should bail here
self.assertRaises(tests_utils.ParserException, self.check_parser,
self.cmd, arglist, verifylist)
def test_show_all_options(self):
arglist = [
self._router.name,
]
verifylist = [
('router', self._router.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_router.assert_called_once_with(
self._router.name, ignore_missing=False)
self.assertEqual(tuple(self.columns), columns)
self.assertEqual(self.data, data)
def _format_compute_security_group_rules(sg_rules):
rules = []
for sg_rule in sg_rules:
rules.append(_format_compute_security_group_rule(sg_rule))
return utils.format_list(rules, separator='\n')
def _format_cluster_output(data):
data['version'] = data.pop('hadoop_version')
data['image'] = data.pop('default_image_id')
data['node_groups'] = _format_node_groups_list(data['node_groups'])
data['anti_affinity'] = osc_utils.format_list(data['anti_affinity'])
def test_format_list_separator(self):
expected = 'a\nb\nc'
actual_pre_sorted = utils.format_list(['a', 'b', 'c'], separator='\n')
actual_unsorted = utils.format_list(['c', 'b', 'a'], separator='\n')
self.assertEqual(expected, actual_pre_sorted)
self.assertEqual(expected, actual_unsorted)
class TestListRouter(TestRouter):
# The routers going to be listed up.
routers = network_fakes.FakeRouter.create_routers(count=3)
columns = (
'ID',
'Name',
'Status',
'State',
'Distributed',
'HA',
'Project',
)
columns_long = columns + (
'Routes',
'External gateway info',
'Availability zones'
)
data = []
for r in routers:
data.append((
r.id,
r.name,
r.status,
router._format_admin_state(r.admin_state_up),
r.distributed,
r.ha,
r.tenant_id,
))
data_long = []
for i in range(0, len(routers)):
r = routers[i]
data_long.append(
data[i] + (
r.routes,
router._format_external_gateway_info(r.external_gateway_info),
osc_utils.format_list(r.availability_zones),
)
)
def setUp(self):
super(TestListRouter, self).setUp()
# Get the command object to test
self.cmd = router.ListRouter(self.app, self.namespace)
self.network.routers = mock.Mock(return_value=self.routers)
def test_router_list_no_options(self):
arglist = []
verifylist = [
('long', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# In base command class Lister in cliff, abstract method take_action()
# returns a tuple containing the column names and an iterable
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_router_list_long(self):
arglist = [
'--long',
]
verifylist = [
('long', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# In base command class Lister in cliff, abstract method take_action()
# returns a tuple containing the column names and an iterable
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
def test_format_list_separator(self):
expected = "a\nb\nc"
actual_pre_sorted = utils.format_list(["a", "b", "c"], separator="\n")
actual_unsorted = utils.format_list(["c", "b", "a"], separator="\n")
self.assertEqual(expected, actual_pre_sorted)
self.assertEqual(expected, actual_unsorted)
class TestCreateSubnet(TestSubnet):
# An IPv4 subnet to be created with mostly default values
_subnet = network_fakes.FakeSubnet.create_one_subnet(
attrs={
'tenant_id': identity_fakes_v3.project_id,
}
)
# Subnet pool to be used to create a subnet from a pool
_subnet_pool = network_fakes.FakeSubnetPool.create_one_subnet_pool()
# An IPv4 subnet to be created using a specific subnet pool
_subnet_from_pool = network_fakes.FakeSubnet.create_one_subnet(
attrs={
'tenant_id': identity_fakes_v3.project_id,
'subnetpool_id': _subnet_pool.id,
'dns_nameservers': ['8.8.8.8',
'8.8.4.4'],
'host_routes': [{'destination': '10.20.20.0/24',
'nexthop': '10.20.20.1'},
{'destination': '10.30.30.0/24',
'nexthop': '10.30.30.1'}],
}
)
# An IPv6 subnet to be created with most options specified
_subnet_ipv6 = network_fakes.FakeSubnet.create_one_subnet(
attrs={
'tenant_id': identity_fakes_v3.project_id,
'cidr': 'fe80:0:0:a00a::/64',
'enable_dhcp': True,
'dns_nameservers': ['fe80:27ff:a00a:f00f::ffff',
'fe80:37ff:a00a:f00f::ffff'],
'allocation_pools': [{'start': 'fe80::a00a:0:c0de:0:100',
'end': 'fe80::a00a:0:c0de:0:f000'},
{'start': 'fe80::a00a:0:c0de:1:100',
'end': 'fe80::a00a:0:c0de:1:f000'}],
'host_routes': [{'destination': 'fe80:27ff:a00a:f00f::/64',
'nexthop': 'fe80:27ff:a00a:f00f::1'},
{'destination': 'fe80:37ff:a00a:f00f::/64',
'nexthop': 'fe80:37ff:a00a:f00f::1'}],
'ip_version': 6,
'gateway_ip': 'fe80::a00a:0:c0de:0:1',
'ipv6_address_mode': 'slaac',
'ipv6_ra_mode': 'slaac',
'subnetpool_id': 'None',
}
)
# The network to be returned from find_network
_network = network_fakes.FakeNetwork.create_one_network(
attrs={
'id': _subnet.network_id,
}
)
columns = (
'allocation_pools',
'cidr',
'dns_nameservers',
'enable_dhcp',
'gateway_ip',
'host_routes',
'id',
'ip_version',
'ipv6_address_mode',
'ipv6_ra_mode',
'name',
'network_id',
'project_id',
'subnetpool_id',
)
data = (
subnet_v2._format_allocation_pools(_subnet.allocation_pools),
_subnet.cidr,
utils.format_list(_subnet.dns_nameservers),
_subnet.enable_dhcp,
_subnet.gateway_ip,
subnet_v2._format_host_routes(_subnet.host_routes),
_subnet.id,
_subnet.ip_version,
_subnet.ipv6_address_mode,
_subnet.ipv6_ra_mode,
_subnet.name,
_subnet.network_id,
_subnet.project_id,
_subnet.subnetpool_id,
)
data_subnet_pool = (
subnet_v2._format_allocation_pools(_subnet_from_pool.allocation_pools),
_subnet_from_pool.cidr,
utils.format_list(_subnet_from_pool.dns_nameservers),
_subnet_from_pool.enable_dhcp,
_subnet_from_pool.gateway_ip,
subnet_v2._format_host_routes(_subnet_from_pool.host_routes),
_subnet_from_pool.id,
_subnet_from_pool.ip_version,
_subnet_from_pool.ipv6_address_mode,
_subnet_from_pool.ipv6_ra_mode,
_subnet_from_pool.name,
_subnet_from_pool.network_id,
_subnet_from_pool.project_id,
_subnet_from_pool.subnetpool_id,
)
data_ipv6 = (
subnet_v2._format_allocation_pools(_subnet_ipv6.allocation_pools),
_subnet_ipv6.cidr,
utils.format_list(_subnet_ipv6.dns_nameservers),
_subnet_ipv6.enable_dhcp,
_subnet_ipv6.gateway_ip,
subnet_v2._format_host_routes(_subnet_ipv6.host_routes),
_subnet_ipv6.id,
_subnet_ipv6.ip_version,
_subnet_ipv6.ipv6_address_mode,
_subnet_ipv6.ipv6_ra_mode,
_subnet_ipv6.name,
_subnet_ipv6.network_id,
_subnet_ipv6.project_id,
_subnet_ipv6.subnetpool_id,
)
def setUp(self):
super(TestCreateSubnet, self).setUp()
# Get the command object to test
self.cmd = subnet_v2.CreateSubnet(self.app, self.namespace)
# Set identity client v3. And get a shortcut to Identity client.
identity_client = identity_fakes_v3.FakeIdentityv3Client(
endpoint=fakes.AUTH_URL,
token=fakes.AUTH_TOKEN,
)
self.app.client_manager.identity = identity_client
self.identity = self.app.client_manager.identity
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.identity.projects
self.projects_mock.get.return_value = fakes.FakeResource(
None,
copy.deepcopy(identity_fakes_v3.PROJECT),
loaded=True,
)
# Get a shortcut to the DomainManager Mock
self.domains_mock = self.identity.domains
self.domains_mock.get.return_value = fakes.FakeResource(
None,
copy.deepcopy(identity_fakes_v3.DOMAIN),
loaded=True,
)
def test_create_no_options(self):
arglist = []
verifylist = []
# Testing that a call without the required argument will fail and
# throw a "ParserExecption"
self.assertRaises(tests_utils.ParserException,
self.check_parser, self.cmd, arglist, verifylist)
def test_create_default_options(self):
# Mock create_subnet and find_network sdk calls to return the
# values we want for this test
self.network.create_subnet = mock.Mock(return_value=self._subnet)
self._network.id = self._subnet.network_id
self.network.find_network = mock.Mock(return_value=self._network)
arglist = [
self._subnet.name,
"--subnet-range", self._subnet.cidr,
"--network", self._subnet.network_id,
]
verifylist = [
('name', self._subnet.name),
('subnet_range', self._subnet.cidr),
('network', self._subnet.network_id),
('ip_version', self._subnet.ip_version),
('gateway', 'auto'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet.assert_called_with(**{
'cidr': self._subnet.cidr,
'enable_dhcp': self._subnet.enable_dhcp,
'ip_version': self._subnet.ip_version,
'name': self._subnet.name,
'network_id': self._subnet.network_id,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def test_create_from_subnet_pool_options(self):
# Mock create_subnet, find_subnet_pool, and find_network sdk calls
# to return the values we want for this test
self.network.create_subnet = \
mock.Mock(return_value=self._subnet_from_pool)
self._network.id = self._subnet_from_pool.network_id
self.network.find_network = mock.Mock(return_value=self._network)
self.network.find_subnet_pool = \
mock.Mock(return_value=self._subnet_pool)
arglist = [
self._subnet_from_pool.name,
"--subnet-pool", self._subnet_from_pool.subnetpool_id,
"--prefix-length", '24',
"--network", self._subnet_from_pool.network_id,
"--ip-version", str(self._subnet_from_pool.ip_version),
"--gateway", self._subnet_from_pool.gateway_ip,
"--dhcp",
]
for dns_addr in self._subnet_from_pool.dns_nameservers:
arglist.append('--dns-nameserver')
arglist.append(dns_addr)
for host_route in self._subnet_from_pool.host_routes:
arglist.append('--host-route')
value = 'gateway=' + host_route.get('nexthop', '') + \
',destination=' + host_route.get('destination', '')
arglist.append(value)
verifylist = [
('name', self._subnet_from_pool.name),
('prefix_length', '24'),
('network', self._subnet_from_pool.network_id),
('ip_version', self._subnet_from_pool.ip_version),
('gateway', self._subnet_from_pool.gateway_ip),
('dns_nameservers', self._subnet_from_pool.dns_nameservers),
('enable_dhcp', self._subnet_from_pool.enable_dhcp),
('host_routes', subnet_v2.convert_entries_to_gateway(
self._subnet_from_pool.host_routes)),
('subnet_pool', self._subnet_from_pool.subnetpool_id),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet.assert_called_with(**{
'dns_nameservers': self._subnet_from_pool.dns_nameservers,
'enable_dhcp': self._subnet_from_pool.enable_dhcp,
'gateway_ip': self._subnet_from_pool.gateway_ip,
'host_routes': self._subnet_from_pool.host_routes,
'ip_version': self._subnet_from_pool.ip_version,
'name': self._subnet_from_pool.name,
'network_id': self._subnet_from_pool.network_id,
'prefixlen': '24',
'subnetpool_id': self._subnet_from_pool.subnetpool_id,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data_subnet_pool, data)
def test_create_options_subnet_range_ipv6(self):
# Mock create_subnet and find_network sdk calls to return the
# values we want for this test
self.network.create_subnet = mock.Mock(return_value=self._subnet_ipv6)
self._network.id = self._subnet_ipv6.network_id
self.network.find_network = mock.Mock(return_value=self._network)
arglist = [
self._subnet_ipv6.name,
"--subnet-range", self._subnet_ipv6.cidr,
"--network", self._subnet_ipv6.network_id,
"--ip-version", str(self._subnet_ipv6.ip_version),
"--ipv6-ra-mode", self._subnet_ipv6.ipv6_ra_mode,
"--ipv6-address-mode", self._subnet_ipv6.ipv6_address_mode,
"--gateway", self._subnet_ipv6.gateway_ip,
"--dhcp",
]
for dns_addr in self._subnet_ipv6.dns_nameservers:
arglist.append('--dns-nameserver')
arglist.append(dns_addr)
for host_route in self._subnet_ipv6.host_routes:
arglist.append('--host-route')
value = 'gateway=' + host_route.get('nexthop', '') + \
',destination=' + host_route.get('destination', '')
arglist.append(value)
for pool in self._subnet_ipv6.allocation_pools:
arglist.append('--allocation-pool')
value = 'start=' + pool.get('start', '') + \
',end=' + pool.get('end', '')
arglist.append(value)
verifylist = [
('name', self._subnet_ipv6.name),
('subnet_range', self._subnet_ipv6.cidr),
('network', self._subnet_ipv6.network_id),
('ip_version', self._subnet_ipv6.ip_version),
('ipv6_ra_mode', self._subnet_ipv6.ipv6_ra_mode),
('ipv6_address_mode', self._subnet_ipv6.ipv6_address_mode),
('gateway', self._subnet_ipv6.gateway_ip),
('dns_nameservers', self._subnet_ipv6.dns_nameservers),
('enable_dhcp', self._subnet_ipv6.enable_dhcp),
('host_routes', subnet_v2.convert_entries_to_gateway(
self._subnet_ipv6.host_routes)),
('allocation_pools', self._subnet_ipv6.allocation_pools),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet.assert_called_with(**{
'cidr': self._subnet_ipv6.cidr,
'dns_nameservers': self._subnet_ipv6.dns_nameservers,
'enable_dhcp': self._subnet_ipv6.enable_dhcp,
'gateway_ip': self._subnet_ipv6.gateway_ip,
'host_routes': self._subnet_ipv6.host_routes,
'ip_version': self._subnet_ipv6.ip_version,
'ipv6_address_mode': self._subnet_ipv6.ipv6_address_mode,
'ipv6_ra_mode': self._subnet_ipv6.ipv6_ra_mode,
'name': self._subnet_ipv6.name,
'network_id': self._subnet_ipv6.network_id,
'allocation_pools': self._subnet_ipv6.allocation_pools,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data_ipv6, data)
def _format_job_template_output(data):
data['mains'] = osc_utils.format_list(
['%s:%s' % (m['name'], m['id']) for m in data['mains']])
data['libs'] = osc_utils.format_list(
['%s:%s' % (l['name'], l['id']) for l in data['libs']])
class TestCreateNetworkIdentityV2(TestNetwork):
# The new network created.
_network = network_fakes.FakeNetwork.create_one_network(
attrs={'tenant_id': identity_fakes_v2.project_id})
columns = (
'admin_state_up',
'id',
'name',
'project_id',
'router_external',
'status',
'subnets',
)
data = (
network._format_admin_state(_network.admin_state_up),
_network.id,
_network.name,
_network.project_id,
network._format_router_external(_network.router_external),
_network.status,
utils.format_list(_network.subnets),
)
def setUp(self):
super(TestCreateNetworkIdentityV2, self).setUp()
self.network.create_network = mock.Mock(return_value=self._network)
# Get the command object to test
self.cmd = network.CreateNetwork(self.app, self.namespace)
# Set identity client v2. And get a shortcut to Identity client.
identity_client = identity_fakes_v2.FakeIdentityv2Client(
endpoint=fakes.AUTH_URL,
token=fakes.AUTH_TOKEN,
)
self.app.client_manager.identity = identity_client
self.identity = self.app.client_manager.identity
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.identity.tenants
self.projects_mock.get.return_value = fakes.FakeResource(
None,
copy.deepcopy(identity_fakes_v2.PROJECT),
loaded=True,
)
# There is no DomainManager Mock in fake identity v2.
def test_create_with_project_identityv2(self):
arglist = [
"--project",
identity_fakes_v2.project_name,
self._network.name,
]
verifylist = [
('admin_state', True),
('shared', None),
('name', self._network.name),
('project', identity_fakes_v2.project_name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_network.assert_called_with(
**{
'admin_state_up': True,
'name': self._network.name,
'tenant_id': identity_fakes_v2.project_id,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def test_create_with_domain_identityv2(self):
arglist = [
"--project",
identity_fakes_v3.project_name,
"--project-domain",
identity_fakes_v3.domain_name,
self._network.name,
]
verifylist = [
('admin_state', True),
('shared', None),
('project', identity_fakes_v3.project_name),
('project_domain', identity_fakes_v3.domain_name),
('name', self._network.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(
AttributeError,
self.cmd.take_action,
parsed_args,
)
