class TestShowRouter(TestRouter):
# The router to set.
_router = network_fakes.FakeRouter.create_one_router()
_port = network_fakes.FakePort.create_one_port({
'device_owner': 'network:router_interface',
'device_id': _router.id
})
setattr(_router,
'interfaces_info',
[{'port_id': _port.id,
'ip_address': _port.fixed_ips[0]['ip_address'],
'subnet_id': _port.fixed_ips[0]['subnet_id']}])
columns = (
'admin_state_up',
'availability_zone_hints',
'availability_zones',
'description',
'distributed',
'external_gateway_info',
'ha',
'id',
'interfaces_info',
'name',
'project_id',
'routes',
'status',
'tags',
)
data = (
router.AdminStateColumn(_router.admin_state_up),
format_columns.ListColumn(_router.availability_zone_hints),
format_columns.ListColumn(_router.availability_zones),
_router.description,
_router.distributed,
router.RouterInfoColumn(_router.external_gateway_info),
_router.ha,
_router.id,
router.RouterInfoColumn(_router.interfaces_info),
_router.name,
_router.tenant_id,
router.RoutesColumn(_router.routes),
_router.status,
format_columns.ListColumn(_router.tags),
)
def setUp(self):
super(TestShowRouter, self).setUp()
self.network.find_router = mock.Mock(return_value=self._router)
self.network.ports = mock.Mock(return_value=[self._port])
# Get the command object to test
self.cmd = router.ShowRouter(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._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.network.ports.assert_called_with(**{
'device_id': self._router.id
})
self.assertEqual(self.columns, columns)
self.assertItemEqual(self.data, data)
def test_show_no_ha_no_distributed(self):
_router = network_fakes.FakeRouter.create_one_router({
'ha': None,
'distributed': None})
arglist = [
_router.name,
]
verifylist = [
('router', _router.name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
with mock.patch.object(
self.network, "find_router", return_value=_router):
columns, data = self.cmd.take_action(parsed_args)
self.assertNotIn("is_distributed", columns)
self.assertNotIn("is_ha", columns)
class TestListRouter(TestRouter):
# The routers going to be listed up.
routers = network_fakes.FakeRouter.create_routers(count=3)
_extensions = network_fakes.FakeExtension.create_one_extension()
columns = (
'ID',
'Name',
'Status',
'State',
'Project',
'Distributed',
'HA',
)
columns_long = columns + (
'Routes',
'External gateway info',
'Availability zones',
'Tags',
)
columns_long_no_az = columns + (
'Routes',
'External gateway info',
'Tags',
)
data = []
for r in routers:
data.append((
r.id,
r.name,
r.status,
router.AdminStateColumn(r.admin_state_up),
r.tenant_id,
r.distributed,
r.ha,
))
router_agent_data = []
for r in routers:
router_agent_data.append((
r.id,
r.name,
r.external_gateway_info,
))
agents_columns = (
'ID',
'Name',
'External Gateway Info',
)
data_long = []
for i in range(0, len(routers)):
r = routers[i]
data_long.append(
data[i] + (
router.RoutesColumn(r.routes),
router.RouterInfoColumn(r.external_gateway_info),
format_columns.ListColumn(r.availability_zones),
format_columns.ListColumn(r.tags),
)
)
data_long_no_az = []
for i in range(0, len(routers)):
r = routers[i]
data_long_no_az.append(
data[i] + (
router.RoutesColumn(r.routes),
router.RouterInfoColumn(r.external_gateway_info),
format_columns.ListColumn(r.tags),
)
)
def setUp(self):
super(TestListRouter, self).setUp()
# Get the command object to test
self.cmd = router.ListRouter(self.app, self.namespace)
self.network.agent_hosted_routers = mock.Mock(
return_value=self.routers)
self.network.routers = mock.Mock(return_value=self.routers)
self.network.find_extension = mock.Mock(return_value=self._extensions)
self.network.find_router = mock.Mock(return_value=self.routers[0])
self._testagent = \
network_fakes.FakeNetworkAgent.create_one_network_agent()
self.network.get_agent = mock.Mock(return_value=self._testagent)
self.network.get_router = mock.Mock(return_value=self.routers[0])
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.assertListItemEqual(self.data, list(data))
def test_router_list_no_ha_no_distributed(self):
_routers = network_fakes.FakeRouter.create_routers({
'ha': None,
'distributed': None},
count=3)
arglist = []
verifylist = [
('long', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
with mock.patch.object(
self.network, "routers", return_value=_routers):
columns, data = self.cmd.take_action(parsed_args)
self.assertNotIn("is_distributed", columns)
self.assertNotIn("is_ha", columns)
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.assertListItemEqual(self.data_long, list(data))
def test_router_list_long_no_az(self):
arglist = [
'--long',
]
verifylist = [
('long', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# to mock, that no availability zone
self.network.find_extension = mock.Mock(return_value=None)
# 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_no_az, columns)
self.assertListItemEqual(self.data_long_no_az, list(data))
def test_list_name(self):
test_name = "fakename"
arglist = [
'--name', test_name,
]
verifylist = [
('long', False),
('name', test_name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with(
**{'name': test_name}
)
self.assertEqual(self.columns, columns)
self.assertListItemEqual(self.data, list(data))
def test_router_list_enable(self):
arglist = [
'--enable',
]
verifylist = [
('long', False),
('enable', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with(
**{'admin_state_up': True, 'is_admin_state_up': True}
)
self.assertEqual(self.columns, columns)
self.assertListItemEqual(self.data, list(data))
def test_router_list_disable(self):
arglist = [
'--disable',
]
verifylist = [
('long', False),
('disable', True)
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with(
**{'admin_state_up': False, 'is_admin_state_up': False}
)
self.assertEqual(self.columns, columns)
self.assertListItemEqual(self.data, list(data))
def test_router_list_project(self):
project = identity_fakes_v3.FakeProject.create_one_project()
self.projects_mock.get.return_value = project
arglist = [
'--project', project.id,
]
verifylist = [
('project', project.id),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
filters = {'tenant_id': project.id, 'project_id': project.id}
self.network.routers.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertListItemEqual(self.data, list(data))
def test_router_list_project_domain(self):
project = identity_fakes_v3.FakeProject.create_one_project()
self.projects_mock.get.return_value = project
arglist = [
'--project', project.id,
'--project-domain', project.domain_id,
]
verifylist = [
('project', project.id),
('project_domain', project.domain_id),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
filters = {'tenant_id': project.id, 'project_id': project.id}
self.network.routers.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertListItemEqual(self.data, list(data))
def test_router_list_agents_no_args(self):
arglist = [
'--agents',
]
verifylist = []
# Missing required router ID should bail here
self.assertRaises(tests_utils.ParserException, self.check_parser,
self.cmd, arglist, verifylist)
def test_router_list_agents(self):
arglist = [
'--agent', self._testagent.id,
]
verifylist = [
('agent', self._testagent.id),
]
attrs = {self._testagent.id, }
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.agent_hosted_routers(
*attrs)
self.assertEqual(self.columns, columns)
self.assertListItemEqual(self.data, list(data))
def test_list_with_tag_options(self):
arglist = [
'--tags', 'red,blue',
'--any-tags', 'red,green',
'--not-tags', 'orange,yellow',
'--not-any-tags', 'black,white',
]
verifylist = [
('tags', ['red', 'blue']),
('any_tags', ['red', 'green']),
('not_tags', ['orange', 'yellow']),
('not_any_tags', ['black', 'white']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with(
**{'tags': 'red,blue',
'any_tags': 'red,green',
'not_tags': 'orange,yellow',
'not_any_tags': 'black,white'}
)
self.assertEqual(self.columns, columns)
self.assertListItemEqual(self.data, list(data))
class TestCreateRouter(TestRouter):
# The new router created.
new_router = network_fakes.FakeRouter.create_one_router()
columns = (
'admin_state_up',
'availability_zone_hints',
'availability_zones',
'description',
'distributed',
'external_gateway_info',
'ha',
'id',
'name',
'project_id',
'routes',
'status',
'tags',
)
data = (
router.AdminStateColumn(new_router.admin_state_up),
format_columns.ListColumn(new_router.availability_zone_hints),
format_columns.ListColumn(new_router.availability_zones),
new_router.description,
new_router.distributed,
router.RouterInfoColumn(new_router.external_gateway_info),
new_router.ha,
new_router.id,
new_router.name,
new_router.tenant_id,
router.RoutesColumn(new_router.routes),
new_router.status,
format_columns.ListColumn(new_router.tags),
)
def setUp(self):
super(TestCreateRouter, self).setUp()
self.network.create_router = mock.Mock(return_value=self.new_router)
self.network.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = router.CreateRouter(self.app, self.namespace)
def test_create_no_options(self):
arglist = []
verifylist = []
self.assertRaises(tests_utils.ParserException, self.check_parser,
self.cmd, arglist, verifylist)
self.assertFalse(self.network.set_tags.called)
def test_create_default_options(self):
arglist = [
self.new_router.name,
]
verifylist = [
('name', self.new_router.name),
('enable', True),
('distributed', False),
('ha', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.network.create_router.assert_called_once_with(**{
'admin_state_up': True,
'name': self.new_router.name,
})
self.assertFalse(self.network.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertItemEqual(self.data, data)
def _test_create_with_ha_options(self, option, ha):
arglist = [
option,
self.new_router.name,
]
verifylist = [
('name', self.new_router.name),
('enable', True),
('distributed', False),
('ha', ha),
('no_ha', not ha),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.network.create_router.assert_called_once_with(**{
'admin_state_up': True,
'name': self.new_router.name,
'ha': ha,
})
self.assertEqual(self.columns, columns)
self.assertItemEqual(self.data, data)
def test_create_with_ha_option(self):
self._test_create_with_ha_options('--ha', True)
def test_create_with_no_ha_option(self):
self._test_create_with_ha_options('--no-ha', False)
def _test_create_with_distributed_options(self, option, distributed):
arglist = [
option,
self.new_router.name,
]
verifylist = [
('name', self.new_router.name),
('enable', True),
('distributed', distributed),
('centralized', not distributed),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.network.create_router.assert_called_once_with(**{
'admin_state_up': True,
'name': self.new_router.name,
'distributed': distributed,
})
self.assertEqual(self.columns, columns)
self.assertItemEqual(self.data, data)
def test_create_with_distributed_option(self):
self._test_create_with_distributed_options('--distributed', True)
def test_create_with_centralized_option(self):
self._test_create_with_distributed_options('--centralized', False)
def test_create_with_AZ_hints(self):
arglist = [
self.new_router.name,
'--availability-zone-hint', 'fake-az',
'--availability-zone-hint', 'fake-az2',
]
verifylist = [
('name', self.new_router.name),
('availability_zone_hints', ['fake-az', 'fake-az2']),
('enable', True),
('distributed', False),
('ha', False)
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.network.create_router.assert_called_once_with(**{
'admin_state_up': True,
'name': self.new_router.name,
'availability_zone_hints': ['fake-az', 'fake-az2'],
})
self.assertEqual(self.columns, columns)
self.assertItemEqual(self.data, data)
def _test_create_with_tag(self, add_tags=True):
arglist = [self.new_router.name]
if add_tags:
arglist += ['--tag', 'red', '--tag', 'blue']
else:
arglist += ['--no-tag']
verifylist = [
('name', self.new_router.name),
('enable', True),
('distributed', False),
('ha', False),
]
if add_tags:
verifylist.append(('tags', ['red', 'blue']))
else:
verifylist.append(('no_tag', True))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.network.create_router.assert_called_once_with(
name=self.new_router.name,
admin_state_up=True
)
if add_tags:
self.network.set_tags.assert_called_once_with(
self.new_router,
tests_utils.CompareBySet(['red', 'blue']))
else:
self.assertFalse(self.network.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertItemEqual(self.data, data)
def test_create_with_tags(self):
self._test_create_with_tag(add_tags=True)
def test_create_with_no_tag(self):
self._test_create_with_tag(add_tags=False)