class TestCreateRouter(TestRouter):
# The new router created.
new_router = network_fakes.FakeRouter.create_one_router()
columns = (
'admin_state_up',
'distributed',
'ha',
'id',
'name',
'project_id',
)
data = (
router._format_admin_state(new_router.admin_state_up),
new_router.distributed,
new_router.ha,
new_router.id,
new_router.name,
new_router.tenant_id,
)
def setUp(self):
super(TestCreateRouter, self).setUp()
self.network.create_router = mock.Mock(return_value=self.new_router)
# Get the command object to test
self.cmd = router.CreateRouter(self.app, self.namespace)
def test_create_no_options(self):
arglist = []
verifylist = []
try:
self.check_parser(self.cmd, arglist, verifylist)
except tests_utils.ParserException:
pass
def test_create_default_options(self):
arglist = [
self.new_router.name,
]
verifylist = [
('name', self.new_router.name),
('admin_state_up', True),
('distributed', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = (self.cmd.take_action(parsed_args))
self.network.create_router.assert_called_with(**{
'admin_state_up': True,
'name': self.new_router.name,
'distributed': False,
})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
class TestShowRouter(TestRouter):
# The router to set.
_router = network_fakes.FakeRouter.create_one_router()
columns = (
'admin_state_up',
'distributed',
'ha',
'id',
'name',
'tenant_id',
)
data = (
router._format_admin_state(_router.admin_state_up),
_router.distributed,
_router.ha,
_router.id,
_router.name,
_router.tenant_id,
)
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 = []
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._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_with(self._router.name,
ignore_missing=False)
self.assertEqual(tuple(self.columns), columns)
self.assertEqual(self.data, 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)
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',
)
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),
)
)
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)
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_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)
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, 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',
'distributed',
'external_gateway_info',
'ha',
'id',
'name',
'project_id',
'routes',
'status',
)
data = (
router._format_admin_state(new_router.admin_state_up),
osc_utils.format_list(new_router.availability_zone_hints),
osc_utils.format_list(new_router.availability_zones),
new_router.distributed,
router._format_external_gateway_info(new_router.external_gateway_info),
new_router.ha,
new_router.id,
new_router.name,
new_router.tenant_id,
new_router.routes,
new_router.status,
)
def setUp(self):
super(TestCreateRouter, self).setUp()
self.network.create_router = mock.Mock(return_value=self.new_router)
# Get the command object to test
self.cmd = router.CreateRouter(self.app, self.namespace)
def test_create_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_create_default_options(self):
arglist = [
self.new_router.name,
]
verifylist = [
('name', self.new_router.name),
('enable', True),
('distributed', 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.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
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),
]
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.assertEqual(self.data, data)
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',
'Distributed',
'HA',
'Project',
)
columns_long = columns + ('Routes', 'External gateway info',
'Availability zones')
columns_long_no_az = columns + (
'Routes',
'External gateway info',
)
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] + (
router._format_routes(r.routes),
router._format_external_gateway_info(r.external_gateway_info),
osc_utils.format_list(r.availability_zones),
))
data_long_no_az = []
for i in range(0, len(routers)):
r = routers[i]
data_long_no_az.append(data[i] + (
router._format_routes(r.routes),
router._format_external_gateway_info(r.external_gateway_info),
))
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)
self.network.find_extension = mock.Mock(return_value=self._extensions)
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_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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(self.data, list(data))
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',
'Distributed',
'HA',
'Project',
)
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._format_admin_state(r.admin_state_up),
r.distributed,
r.ha,
r.tenant_id,
))
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._format_routes(r.routes),
router._format_router_info(r.external_gateway_info),
osc_utils.format_list(r.availability_zones),
osc_utils.format_list(r.tags),
))
data_long_no_az = []
for i in range(0, len(routers)):
r = routers[i]
data_long_no_az.append(data[i] + (
router._format_routes(r.routes),
router._format_router_info(r.external_gateway_info),
osc_utils.format_list(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.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_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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(self.data, list(data))
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._format_admin_state(_router.admin_state_up),
osc_utils.format_list(_router.availability_zone_hints),
osc_utils.format_list(_router.availability_zones),
_router.description,
_router.distributed,
router._format_router_info(_router.external_gateway_info),
_router.ha,
_router.id,
router._format_router_info(_router.interfaces_info),
_router.name,
_router.tenant_id,
router._format_routes(_router.routes),
_router.status,
osc_utils.format_list(_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.assertEqual(self.data, 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._format_admin_state(new_router.admin_state_up),
osc_utils.format_list(new_router.availability_zone_hints),
osc_utils.format_list(new_router.availability_zones),
new_router.description,
new_router.distributed,
router._format_router_info(new_router.external_gateway_info),
new_router.ha,
new_router.id,
new_router.name,
new_router.tenant_id,
router._format_routes(new_router.routes),
new_router.status,
osc_utils.format_list(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(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)
