def test_format_list_of_dicts(self):
expected = "a='b', c='d'\ne='f'"
sorted_data = [{'a': 'b', 'c': 'd'}, {'e': 'f'}]
unsorted_data = [{'c': 'd', 'a': 'b'}, {'e': 'f'}]
self.assertEqual(expected, utils.format_list_of_dicts(sorted_data))
self.assertEqual(expected, utils.format_list_of_dicts(unsorted_data))
self.assertEqual('', utils.format_list_of_dicts([]))
self.assertEqual('', utils.format_list_of_dicts([{}]))
def test_format_list_of_dicts(self):
expected = "a='b', c='d'\ne='f'"
sorted_data = [{'a': 'b', 'c': 'd'}, {'e': 'f'}]
unsorted_data = [{'c': 'd', 'a': 'b'}, {'e': 'f'}]
self.assertEqual(expected, utils.format_list_of_dicts(sorted_data))
self.assertEqual(expected, utils.format_list_of_dicts(unsorted_data))
self.assertEqual('', utils.format_list_of_dicts([]))
self.assertEqual('', utils.format_list_of_dicts([{}]))
self.assertIsNone(utils.format_list_of_dicts(None))
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',
'description',
'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.description,
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",
"description",
"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.description,
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 take_action(self, parsed_args):
mgr = self.app.client_manager
subnet = mgr.network.find_subnet(parsed_args.name)
port = mgr.network.find_port(parsed_args.name)
router = mgr.network.find_router('internal-external',
ignore_missing=False)
routes = [
x for x in router.routes
if subnet is not None and x['destination'] == subnet.cidr
]
# Delete route, if applicable
if subnet is not None:
mgr.network.update_router(
router,
routes=[x for x in router.routes if x not in routes],
)
# Delete port, if applicable
if port is not None:
mgr.network.delete_port(port)
# Delete subnet, if applicable
if subnet is not None:
mgr.network.delete_subnet(subnet)
return zip(
*{
'name': parsed_args.name,
'subnet_id': None if subnet is None else subnet.id,
'port_id': None if port is None else port.id,
'routes': format_list_of_dicts(routes),
}.items())
class TestShowNetworkTrunk(test_fakes.TestNeutronClientOSCV2):
# The trunk to set.
_trunk = fakes.FakeTrunk.create_one_trunk()
columns = (
'admin_state_up',
'description',
'id',
'name',
'port_id',
'project_id',
'status',
'sub_ports',
)
data = (
trunk._format_admin_state(_trunk['admin_state_up']),
_trunk['description'],
_trunk['id'],
_trunk['name'],
_trunk['port_id'],
_trunk['project_id'],
_trunk['status'],
utils.format_list_of_dicts(_trunk['sub_ports']),
)
def setUp(self):
super(TestShowNetworkTrunk, self).setUp()
mock.patch('neutronclient.osc.v2.trunk.network_trunk._get_id',
new=_get_id).start()
self.neutronclient.show_trunk = mock.Mock(
return_value={trunk.TRUNK: self._trunk})
# Get the command object to test
self.cmd = trunk.ShowNetworkTrunk(self.app, self.namespace)
def test_show_no_options(self):
arglist = []
verifylist = []
self.assertRaises(tests_utils.ParserException, self.check_parser,
self.cmd, arglist, verifylist)
def test_show_all_options(self):
arglist = [
self._trunk['id'],
]
verifylist = [
('trunk', self._trunk['id']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.neutronclient.show_trunk.assert_called_once_with(
self._trunk['id'])
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def _format_ranges(item):
item = utils.format_list_of_dicts(item)
# we want to remove some fields
# to match the output to neutron providernet-list
separator = ', '
item = item.split(separator)
item = [s for s in item if "name" in s or "maximum" in s or "minimum" in s]
return separator.join(item)
def _format_network_security_group_rules(sg_rules):
# For readability and to align with formatting compute security group
# rules, trim keys with caller known (e.g. security group and tenant ID)
# or empty values.
for sg_rule in sg_rules:
empty_keys = [k for k, v in sg_rule.items() if not v]
for key in empty_keys:
sg_rule.pop(key)
sg_rule.pop('security_group_id', None)
sg_rule.pop('project_id', None)
return utils.format_list_of_dicts(sg_rules)
def get_data(self):
return (
trunk._format_admin_state(self._trunk['admin_state_up']),
self._trunk['description'],
self._trunk['id'],
self._trunk['name'],
self._trunk['port_id'],
self._trunk['project_id'],
self._trunk['status'],
utils.format_list_of_dicts(self._trunk['sub_ports']),
)
def get_data(self):
return (
trunk._format_admin_state(self._trunk['admin_state_up']),
self._trunk['description'],
self._trunk['id'],
self._trunk['name'],
self._trunk['port_id'],
self._trunk['project_id'],
self._trunk['status'],
utils.format_list_of_dicts(self._trunk['sub_ports']),
)
def _format_network_security_group_rules(sg_rules):
# For readability and to align with formatting compute security group
# rules, trim keys with caller known (e.g. security group and tenant ID)
# or empty values.
for sg_rule in sg_rules:
empty_keys = [k for k, v in six.iteritems(sg_rule) if not v]
for key in empty_keys:
sg_rule.pop(key)
sg_rule.pop('security_group_id', None)
sg_rule.pop('tenant_id', None)
return utils.format_list_of_dicts(sg_rules)
def _format_host_routes(data):
# Map the host route keys to match --host-route option.
return utils.format_list_of_dicts(convert_entries_to_gateway(data))
def human_readable(self):
return utils.format_list_of_dicts(self._value)
class TestSetNetworkTrunk(test_fakes.TestNeutronClientOSCV2):
# Create trunks to be listed.
_trunk = fakes.FakeTrunk.create_one_trunk()
columns = (
'admin_state_up',
'id',
'name',
'description',
'port_id',
'project_id',
'status',
'sub_ports',
)
data = (
trunk._format_admin_state(_trunk['admin_state_up']),
_trunk['id'],
_trunk['name'],
_trunk['description'],
_trunk['port_id'],
_trunk['project_id'],
_trunk['status'],
utils.format_list_of_dicts(_trunk['sub_ports']),
)
def setUp(self):
super(TestSetNetworkTrunk, self).setUp()
mock.patch('neutronclient.osc.v2.trunk.network_trunk._get_id',
new=_get_id).start()
self.neutronclient.update_trunk = mock.Mock(
return_value={trunk.TRUNK: self._trunk})
self.neutronclient.trunk_add_subports = mock.Mock(
return_value=self._trunk)
# Get the command object to test
self.cmd = trunk.SetNetworkTrunk(self.app, self.namespace)
def _test_set_network_trunk_attr(self, attr, value):
arglist = [
'--%s' % attr,
value,
self._trunk[attr],
]
verifylist = [
(attr, value),
('trunk', self._trunk[attr]),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {
attr: value,
}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk[attr], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_name(self):
self._test_set_network_trunk_attr('name', 'trunky')
def test_test_set_network_trunk_description(self):
self._test_set_network_trunk_attr('description', 'description')
def test_set_network_trunk_admin_state_up_disable(self):
arglist = [
'--disable',
self._trunk['name'],
]
verifylist = [
('disable', True),
('trunk', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {
'admin_state_up': False,
}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_admin_state_up_enable(self):
arglist = [
'--enable',
self._trunk['name'],
]
verifylist = [
('enable', True),
('trunk', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {
'admin_state_up': True,
}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_nothing(self):
arglist = [
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_subports(self):
subport = self._trunk['sub_ports'][0]
arglist = [
'--subport',
'port=%(port)s,segmentation-type=%(seg_type)s,'
'segmentation-id=%(seg_id)s' % {
'seg_id': subport['segmentation_id'],
'seg_type': subport['segmentation_type'],
'port': subport['port_id']
},
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
('set_subports', [{
'port':
subport['port_id'],
'segmentation-id':
str(subport['segmentation_id']),
'segmentation-type':
subport['segmentation_type']
}]),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.neutronclient.trunk_add_subports.assert_called_once_with(
self._trunk['name'], {'sub_ports': [subport]})
self.assertIsNone(result)
def test_set_trunk_attrs_with_exception(self):
arglist = [
'--name',
'reallylongname',
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
('name', 'reallylongname'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.neutronclient.update_trunk = (mock.Mock(
side_effect=exceptions.CommandError))
with testtools.ExpectedException(exceptions.CommandError) as e:
self.cmd.take_action(parsed_args)
self.assertEqual(
"Failed to set trunk '%s': " % self._trunk['name'], str(e))
attrs = {'name': 'reallylongname'}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.neutronclient.trunk_add_subports.assert_not_called()
def test_set_trunk_add_subport_with_exception(self):
arglist = [
'--subport',
'port=invalid_subport',
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
('set_subports', [{
'port': 'invalid_subport'
}]),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.neutronclient.trunk_add_subports = (mock.Mock(
side_effect=exceptions.CommandError))
with testtools.ExpectedException(exceptions.CommandError) as e:
self.cmd.take_action(parsed_args)
self.assertEqual(
"Failed to add subports to trunk '%s': " % self._trunk['name'],
str(e))
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: {}})
self.neutronclient.trunk_add_subports.assert_called_once_with(
self._trunk['name'],
{'sub_ports': [{
'port_id': 'invalid_subport'
}]})
class TestListPort(TestPort):
_ports = network_fakes.FakePort.create_ports(count=3)
columns = (
'ID',
'Name',
'MAC Address',
'Fixed IP Addresses',
)
data = []
for prt in _ports:
data.append((
prt.id,
prt.name,
prt.mac_address,
utils.format_list_of_dicts(prt.fixed_ips),
))
def setUp(self):
super(TestListPort, self).setUp()
# Get the command object to test
self.cmd = port.ListPort(self.app, self.namespace)
self.network.ports = mock.Mock(return_value=self._ports)
fake_router = network_fakes.FakeRouter.create_one_router({
'id': 'fake-router-id',
})
self.network.find_router = mock.Mock(return_value=fake_router)
def test_port_list_no_options(self):
arglist = []
verifylist = []
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_port_list_router_opt(self):
arglist = [
'--router', 'fake-router-name',
]
verifylist = [
('router', 'fake-router-name')
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with(**{
'device_id': 'fake-router-id'
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_port_list_device_owner_opt(self):
arglist = [
'--device-owner', self._ports[0].device_owner,
]
verifylist = [
('device_owner', self._ports[0].device_owner)
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with(**{
'device_owner': self._ports[0].device_owner
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_port_list_all_opt(self):
arglist = [
'--device-owner', self._ports[0].device_owner,
'--router', 'fake-router-name',
]
verifylist = [
('device_owner', self._ports[0].device_owner),
('router', 'fake-router-name')
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with(**{
'device_owner': self._ports[0].device_owner,
'device_id': 'fake-router-id'
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def _format_routes(routes):
# Map the route keys to match --route option.
for route in routes:
if 'nexthop' in route:
route['gateway'] = route.pop('nexthop')
return utils.format_list_of_dicts(routes)
class TestUnsetNetworkTrunk(test_fakes.TestNeutronClientOSCV2):
_trunk = fakes.FakeTrunk.create_one_trunk()
columns = (
'admin_state_up',
'id',
'name',
'port_id',
'project_id',
'status',
'sub_ports',
)
data = (
trunk._format_admin_state(_trunk['admin_state_up']),
_trunk['id'],
_trunk['name'],
_trunk['port_id'],
_trunk['project_id'],
_trunk['status'],
utils.format_list_of_dicts(_trunk['sub_ports']),
)
def setUp(self):
super(TestUnsetNetworkTrunk, self).setUp()
mock.patch('neutronclient.osc.v2.trunk.network_trunk._get_id',
new=_get_id).start()
self.neutronclient.trunk_remove_subports = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = trunk.UnsetNetworkTrunk(self.app, self.namespace)
def test_unset_network_trunk_subport(self):
subport = self._trunk['sub_ports'][0]
arglist = [
"--subport",
subport['port_id'],
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
('unset_subports', [subport['port_id']]),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.neutronclient.trunk_remove_subports.assert_called_once_with(
self._trunk['name'],
{trunk.SUB_PORTS: [{
'port_id': subport['port_id']
}]})
self.assertIsNone(result)
def test_unset_subport_no_arguments_fail(self):
arglist = [
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
]
self.assertRaises(tests_utils.ParserException, self.check_parser,
self.cmd, arglist, verifylist)
def take_action(self, parsed_args):
mgr = self.app.client_manager
if parsed_args.network is None:
parsed_args.network = parsed_args.name.split('-', 1)[0]
if parsed_args.dns_name is None:
parsed_args.dns_name = parsed_args.name.split('-', 1)[1]
# Identify network
network = mgr.network.find_network(parsed_args.network,
ignore_missing=False)
# Identify project
project = find_project(
mgr.identity, (network.project_id if parsed_args.project is None
else parsed_args.project))
# Create subnet
if mgr.network.find_subnet(parsed_args.name):
raise CommandError('Subnet %s already exists' % parsed_args.name)
subnet = mgr.network.create_subnet(
name=parsed_args.name,
project_id=project.id,
network_id=network.id,
ip_version=6,
prefixlen=parsed_args.prefix_length,
use_default_subnet_pool=True,
enable_dhcp=False,
)
mgr.network.update_subnet(
subnet,
gateway_ip=None,
allocation_pools=[],
)
# Create port
if mgr.network.find_port(parsed_args.name):
raise CommandError('Port %s already exists' % parsed_args.name)
port = mgr.network.create_port(
name=parsed_args.name,
project_id=project.id,
network_id=network.id,
dns_name=parsed_args.dns_name,
description="Routing port",
allowed_address_pairs=[{
'ip_address': subnet.cidr
}],
)
nexthop = next(x['ip_address'] for x in port.fixed_ips
if valid_ipv6(x['ip_address']))
# Create route
router = mgr.network.find_router('internal-external',
ignore_missing=False)
routes = [{
'destination': subnet.cidr,
'nexthop': nexthop,
}]
mgr.network.update_router(
router,
routes=(router.routes + routes),
)
return zip(
*{
'name': parsed_args.name,
'project_id': project.id,
'network_id': network.id,
'subnet_id': subnet.id,
'port_id': port.id,
'dns_name': parsed_args.dns_name,
'cidr': subnet.cidr,
'fixed_ips': format_list_of_dicts(port.fixed_ips),
'dns_assignment': format_list_of_dicts(port.dns_assignment),
'routes': format_list_of_dicts(routes),
}.items())
def _format_routes(routes):
# Map the route keys to match --route option.
for route in routes:
if 'nexthop' in route:
route['gateway'] = route.pop('nexthop')
return utils.format_list_of_dicts(routes)
class TestListPort(TestPort):
_ports = network_fakes.FakePort.create_ports(count=3)
columns = (
'ID',
'Name',
'MAC Address',
'Fixed IP Addresses',
'Status',
)
columns_long = (
'ID',
'Name',
'MAC Address',
'Fixed IP Addresses',
'Status',
'Security Groups',
'Device Owner',
)
data = []
for prt in _ports:
data.append((
prt.id,
prt.name,
prt.mac_address,
utils.format_list_of_dicts(prt.fixed_ips),
prt.status,
))
data_long = []
for prt in _ports:
data_long.append((
prt.id,
prt.name,
prt.mac_address,
utils.format_list_of_dicts(prt.fixed_ips),
prt.status,
utils.format_list(prt.security_groups),
prt.device_owner,
))
def setUp(self):
super(TestListPort, self).setUp()
# Get the command object to test
self.cmd = port.ListPort(self.app, self.namespace)
self.network.ports = mock.Mock(return_value=self._ports)
fake_router = network_fakes.FakeRouter.create_one_router({
'id':
'fake-router-id',
})
fake_network = network_fakes.FakeNetwork.create_one_network({
'id':
'fake-network-id',
})
self.network.find_router = mock.Mock(return_value=fake_router)
self.network.find_network = mock.Mock(return_value=fake_network)
self.app.client_manager.compute = mock.Mock()
def test_port_list_no_options(self):
arglist = []
verifylist = []
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_port_list_router_opt(self):
arglist = [
'--router',
'fake-router-name',
]
verifylist = [('router', 'fake-router-name')]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with(
**{'device_id': 'fake-router-id'})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@mock.patch.object(utils, 'find_resource')
def test_port_list_with_server_option(self, mock_find):
fake_server = compute_fakes.FakeServer.create_one_server()
mock_find.return_value = fake_server
arglist = [
'--server',
'fake-server-name',
]
verifylist = [
('server', 'fake-server-name'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with(device_id=fake_server.id)
mock_find.assert_called_once_with(mock.ANY, 'fake-server-name')
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_port_list_device_owner_opt(self):
arglist = [
'--device-owner',
self._ports[0].device_owner,
]
verifylist = [('device_owner', self._ports[0].device_owner)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with(
**{'device_owner': self._ports[0].device_owner})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_port_list_all_opt(self):
arglist = [
'--device-owner',
self._ports[0].device_owner,
'--router',
'fake-router-name',
'--network',
'fake-network-name',
]
verifylist = [('device_owner', self._ports[0].device_owner),
('router', 'fake-router-name'),
('network', 'fake-network-name')]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ports.assert_called_once_with(
**{
'device_owner': self._ports[0].device_owner,
'device_id': 'fake-router-id',
'network_id': 'fake-network-id'
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
def test_list_port_with_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.ports.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
def _format_dns_assignment(dns_assignment):
return utils.format_list_of_dicts(dns_assignment) \
if dns_assignment else None
class TestCreateNetworkTrunk(test_fakes.TestNeutronClientOSCV2):
# The new trunk created
_trunk = fakes.FakeTrunk.create_one_trunk()
columns = (
'admin_state_up',
'id',
'name',
'port_id',
'project_id',
'status',
'sub_ports',
)
data = (
trunk._format_admin_state(_trunk['admin_state_up']),
_trunk['id'],
_trunk['name'],
_trunk['port_id'],
_trunk['project_id'],
_trunk['status'],
utils.format_list_of_dicts(_trunk['sub_ports']),
)
def setUp(self):
super(TestCreateNetworkTrunk, self).setUp()
mock.patch('neutronclient.osc.v2.trunk.network_trunk._get_id',
new=_get_id).start()
self.neutronclient.create_trunk = mock.Mock(
return_value={trunk.TRUNK: self._trunk})
# Get the command object to test
self.cmd = trunk.CreateNetworkTrunk(self.app, self.namespace)
def test_create_no_options(self):
arglist = []
verifylist = []
self.assertRaises(tests_utils.ParserException, self.check_parser,
self.cmd, arglist, verifylist)
def test_create_default_options(self):
arglist = [
"--parent-port",
self._trunk['port_id'],
self._trunk['name'],
]
verifylist = [
('parent_port', self._trunk['port_id']),
('name', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.neutronclient.create_trunk.assert_called_once_with({
trunk.TRUNK: {
'name': self._trunk['name'],
'admin_state_up': self._trunk['admin_state_up'],
'port_id': self._trunk['port_id']
}
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def test_create_full_options(self):
subport = self._trunk['sub_ports'][0]
arglist = [
"--disable",
"--parent-port",
self._trunk['port_id'],
"--subport",
'port=%(port)s,segmentation-type=%(seg_type)s,'
'segmentation-id=%(seg_id)s' % {
'seg_id': subport['segmentation_id'],
'seg_type': subport['segmentation_type'],
'port': subport['port_id']
},
self._trunk['name'],
]
verifylist = [
('name', self._trunk['name']),
('parent_port', self._trunk['port_id']),
('add_subports', [{
'port':
subport['port_id'],
'segmentation-id':
str(subport['segmentation_id']),
'segmentation-type':
subport['segmentation_type']
}]),
('disable', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.neutronclient.create_trunk.assert_called_once_with({
trunk.TRUNK: {
'name': self._trunk['name'],
'admin_state_up': False,
'sub_ports': [subport],
'port_id': self._trunk['port_id']
}
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def test_create_trunk_with_subport_invalid_segmentation_id_fail(self):
subport = self._trunk['sub_ports'][0]
arglist = [
"--parent-port",
self._trunk['port_id'],
"--subport",
"port=%(port)s,segmentation-type=%(seg_type)s,"
"segmentation-id=boom" % {
'seg_type': subport['segmentation_type'],
'port': subport['port_id']
},
self._trunk['name'],
]
verifylist = [
('name', self._trunk['name']),
('parent_port', self._trunk['port_id']),
('add_subports', [{
'port': subport['port_id'],
'segmentation-id': 'boom',
'segmentation-type': subport['segmentation_type']
}]),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
try:
self.cmd.take_action(parsed_args)
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual("Segmentation-id 'boom' is not an integer",
str(e))
def human_readable(self):
# Map the route keys to match --route option.
for route in self._value or []:
if 'nexthop' in route:
route['gateway'] = route.pop('nexthop')
return utils.format_list_of_dicts(self._value)
def human_readable(self):
# Map the host route keys to match --host-route option.
return utils.format_list_of_dicts(
convert_entries_to_gateway(self._value))
class TestSetNetworkTrunk(test_fakes.TestNeutronClientOSCV2):
# Create trunks to be listed.
_trunk = fakes.FakeTrunk.create_one_trunk()
columns = (
'admin_state_up',
'id',
'name',
'port_id',
'project_id',
'status',
'sub_ports',
)
data = (
trunk._format_admin_state(_trunk['admin_state_up']),
_trunk['id'],
_trunk['name'],
_trunk['port_id'],
_trunk['project_id'],
_trunk['status'],
utils.format_list_of_dicts(_trunk['sub_ports']),
)
def setUp(self):
super(TestSetNetworkTrunk, self).setUp()
mock.patch('neutronclient.osc.v2.trunk.network_trunk._get_id',
new=_get_id).start()
self.neutronclient.update_trunk = mock.Mock(
return_value={trunk.TRUNK: self._trunk})
self.neutronclient.trunk_add_subports = mock.Mock(
return_value=self._trunk)
# Get the command object to test
self.cmd = trunk.SetNetworkTrunk(self.app, self.namespace)
def test_set_network_trunk_name(self):
arglist = [
'--name',
'trunky',
self._trunk['name'],
]
verifylist = [
('name', 'trunky'),
('trunk', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {
'name': 'trunky',
}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_admin_state_up_disable(self):
arglist = [
'--disable',
self._trunk['name'],
]
verifylist = [
('disable', True),
('trunk', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {
'admin_state_up': False,
}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_admin_state_up_enable(self):
arglist = [
'--enable',
self._trunk['name'],
]
verifylist = [
('enable', True),
('trunk', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {
'admin_state_up': True,
}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_nothing(self):
arglist = [
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {}
self.neutronclient.update_trunk.assert_called_once_with(
self._trunk['name'], {trunk.TRUNK: attrs})
self.assertIsNone(result)
def test_set_network_trunk_subports(self):
subport = self._trunk['sub_ports'][0]
arglist = [
"--subport",
'port=%(port)s,segmentation-type=%(seg_type)s,'
'segmentation-id=%(seg_id)s' % {
'seg_id': subport['segmentation_id'],
'seg_type': subport['segmentation_type'],
'port': subport['port_id']
},
self._trunk['name'],
]
verifylist = [
('trunk', self._trunk['name']),
('set_subports', [{
'port':
subport['port_id'],
'segmentation-id':
str(subport['segmentation_id']),
'segmentation-type':
subport['segmentation_type']
}]),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.neutronclient.trunk_add_subports.assert_called_once_with(
self._trunk['name'], {'sub_ports': [subport]})
self.assertIsNone(result)
def _format_host_routes(data):
# Map the host route keys to match --host-route option.
return utils.format_list_of_dicts(convert_entries_to_gateway(data))
def weekly_data(self):
if self.weekdata:
for data in self.weekdata:
time_long = data["period_start_date"]
data["period_start_date"] = utils.format_time(time_long)
return formatter.format_list_of_dicts(self.weekdata)
