openstack
/
python-openstackclient
Code Issues Proposed changes

network tag UT: avoid using mix-in test class 

This is a follow-up patch on https://review.openstack.org/#/c/461195/
There is a suggestion to keep test code more straight-forward
and avoid using mix-in to reduce the code complexity.
This commit moves all logic implemented in _test_tag.py
into individual network tests.

Change-Id: I0a9f8c6cd758db9035b0fd60ce4b9bfc791b6cbd
This commit is contained in:
Akihiro Motoki 2017-07-25 09:22:29 +00:00
parent ad21588b20
commit 78a832441a
6 changed files with 628 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
openstackclient/tests/unit/network/v2/_test_tag.py
View File

@ -1,190 +0,0 @@
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
from openstackclient.tests.unit import utils as tests_utils
class TestCreateTagMixin(object):
"""Test case mixin to test network tag operation for resource creation.
* Each test class must create a mock for self.network.set_tags
* If you test tag operation combined with other options,
you need to write test(s) directly in individual test cases.
* The following instance attributes must be defined:
* _tag_test_resource: Test resource returned by mocked create_<resource>.
* _tag_create_resource_mock: Mocked create_<resource> method of SDK.
* _tag_create_required_arglist: List of required arguments when creating
a resource with default options.
* _tag_create_required_verifylist: List of expected parsed_args params
when creating a resource with default options.
* _tag_create_required_attrs: Expected attributes passed to a mocked
create_resource method when creating a resource with default options.
"""
def _test_create_with_tag(self, add_tags=True):
arglist = self._tag_create_required_arglist[:]
if add_tags:
arglist += ['--tag', 'red', '--tag', 'blue']
else:
arglist += ['--no-tag']
verifylist = self._tag_create_required_verifylist[:]
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._tag_create_resource_mock.assert_called_once_with(
**self._tag_create_required_attrs)
if add_tags:
self.network.set_tags.assert_called_once_with(
self._tag_test_resource,
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)
class TestListTagMixin(object):
"""Test case mixin to test network tag operation for resource listing.
* A test resource returned by find_<resource> must contains
"red" and "green" tags.
* Each test class must create a mock for self.network.set_tags
* If you test tag operation combined with other options,
you need to write test(s) directly in individual test cases.
* The following instance attributes must be defined:
* _tag_create_resource_mock: Mocked list_<resource> method of SDK.
"""
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._tag_list_resource_mock.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 TestSetTagMixin(object):
"""Test case mixin to test network tag operation for resource update.
* A test resource returned by find_<resource> must contains
"red" and "green" tags.
* Each test class must create a mock for self.network.set_tags
* If you test tag operation combined with other options,
you need to write test(s) directly in individual test cases.
* The following instance attributes must be defined:
* _tag_resource_name: positional arg name of a resource to be updated.
* _tag_test_resource: Test resource returned by mocked update_<resource>.
* _tag_update_resource_mock: Mocked update_<resource> method of SDK.
"""
def _test_set_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['red', 'blue', 'green']
else:
arglist = ['--no-tag']
verifylist = [('no_tag', True)]
expected_args = []
arglist.append(self._tag_test_resource.name)
verifylist.append(
(self._tag_resource_name, self._tag_test_resource.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self._tag_update_resource_mock.called)
self.network.set_tags.assert_called_once_with(
self._tag_test_resource,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_set_with_tags(self):
self._test_set_tags(with_tags=True)
def test_set_with_no_tag(self):
self._test_set_tags(with_tags=False)
class TestUnsetTagMixin(object):
"""Test case mixin to test network tag operation for resource update.
* Each test class must create a mock for self.network.set_tags
* If you test tag operation combined with other options,
you need to write test(s) directly in individual test cases.
* The following instance attributes must be defined:
* _tag_resource_name: positional arg name of a resource to be updated.
* _tag_test_resource: Test resource returned by mocked update_<resource>.
* _tag_update_resource_mock: Mocked update_<resource> method of SDK.
"""
def _test_unset_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['green']
else:
arglist = ['--all-tag']
verifylist = [('all_tag', True)]
expected_args = []
arglist.append(self._tag_test_resource.name)
verifylist.append(
(self._tag_resource_name, self._tag_test_resource.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self._tag_update_resource_mock.called)
self.network.set_tags.assert_called_once_with(
self._tag_test_resource,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_unset_with_tags(self):
self._test_unset_tags(with_tags=True)
def test_unset_with_all_tag(self):
self._test_unset_tags(with_tags=False)

154
openstackclient/tests/unit/network/v2/test_network.py
View File

@ -22,7 +22,6 @@ from openstackclient.network.v2 import network
from openstackclient.tests.unit import fakes
from openstackclient.tests.unit.identity.v2_0 import fakes as identity_fakes_v2
from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
from openstackclient.tests.unit.network.v2 import _test_tag
from openstackclient.tests.unit.network.v2 import fakes as network_fakes
from openstackclient.tests.unit import utils as tests_utils
@ -42,7 +41,7 @@ class TestNetwork(network_fakes.TestNetworkV2):
self.domains_mock = self.app.client_manager.identity.domains
class TestCreateNetworkIdentityV3(TestNetwork, _test_tag.TestCreateTagMixin):
class TestCreateNetworkIdentityV3(TestNetwork):
project = identity_fakes_v3.FakeProject.create_one_project()
domain = identity_fakes_v3.FakeDomain.create_one_domain()
@ -115,22 +114,6 @@ class TestCreateNetworkIdentityV3(TestNetwork, _test_tag.TestCreateTagMixin):
self.domains_mock.get.return_value = self.domain
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
# TestCreateTagMixin
self._tag_test_resource = self._network
self._tag_create_resource_mock = self.network.create_network
self._tag_create_required_arglist = [self._network.name]
self._tag_create_required_verifylist = [
('name', self._network.name),
('enable', True),
('share', None),
('project', None),
('external', False),
]
self._tag_create_required_attrs = {
'admin_state_up': True,
'name': self._network.name,
}
def test_create_no_options(self):
arglist = []
verifylist = []
@ -247,6 +230,44 @@ class TestCreateNetworkIdentityV3(TestNetwork, _test_tag.TestCreateTagMixin):
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def _test_create_with_tag(self, add_tags=True):
arglist = [self._network.name]
if add_tags:
arglist += ['--tag', 'red', '--tag', 'blue']
else:
arglist += ['--no-tag']
verifylist = [
('name', self._network.name),
('enable', True),
('share', None),
('project', None),
('external', 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_network.assert_called_once_with(
name=self._network.name, admin_state_up=True)
if add_tags:
self.network.set_tags.assert_called_once_with(
self._network,
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)
class TestCreateNetworkIdentityV2(TestNetwork):
@ -461,7 +482,7 @@ class TestDeleteNetwork(TestNetwork):
self.network.delete_network.assert_has_calls(calls)
class TestListNetwork(TestNetwork, _test_tag.TestListTagMixin):
class TestListNetwork(TestNetwork):
# The networks going to be listed up.
_network = network_fakes.FakeNetwork.create_networks(count=3)
@ -820,8 +841,33 @@ class TestListNetwork(TestNetwork, _test_tag.TestListTagMixin):
self.assertEqual(self.columns, columns)
self.assertEqual(list(data), list(self.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)
class TestSetNetwork(TestNetwork, _test_tag.TestSetTagMixin):
self.network.networks.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 TestSetNetwork(TestNetwork):
# The network to set.
_network = network_fakes.FakeNetwork.create_one_network(
@ -841,11 +887,6 @@ class TestSetNetwork(TestNetwork, _test_tag.TestSetTagMixin):
# Get the command object to test
self.cmd = network.SetNetwork(self.app, self.namespace)
# TestSetTagMixin
self._tag_resource_name = 'network'
self._tag_test_resource = self._network
self._tag_update_resource_mock = self.network.update_network
def test_set_this(self):
arglist = [
self._network.name,
@ -939,6 +980,34 @@ class TestSetNetwork(TestNetwork, _test_tag.TestSetTagMixin):
self.assertFalse(self.network.set_tags.called)
self.assertIsNone(result)
def _test_set_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['red', 'blue', 'green']
else:
arglist = ['--no-tag']
verifylist = [('no_tag', True)]
expected_args = []
arglist.append(self._network.name)
verifylist.append(
('network', self._network.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_network.called)
self.network.set_tags.assert_called_once_with(
self._network,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_set_with_tags(self):
self._test_set_tags(with_tags=True)
def test_set_with_no_tag(self):
self._test_set_tags(with_tags=False)
class TestShowNetwork(TestNetwork):
@ -1024,7 +1093,7 @@ class TestShowNetwork(TestNetwork):
self.assertEqual(self.data, data)
class TestUnsetNetwork(TestNetwork, _test_tag.TestUnsetTagMixin):
class TestUnsetNetwork(TestNetwork):
# The network to set.
_network = network_fakes.FakeNetwork.create_one_network(
@ -1044,11 +1113,6 @@ class TestUnsetNetwork(TestNetwork, _test_tag.TestUnsetTagMixin):
# Get the command object to test
self.cmd = network.UnsetNetwork(self.app, self.namespace)
# TestUnsetNetwork
self._tag_resource_name = 'network'
self._tag_test_resource = self._network
self._tag_update_resource_mock = self.network.update_network
def test_unset_nothing(self):
arglist = [self._network.name, ]
verifylist = [('network', self._network.name), ]
@ -1059,3 +1123,31 @@ class TestUnsetNetwork(TestNetwork, _test_tag.TestUnsetTagMixin):
self.assertFalse(self.network.update_network.called)
self.assertFalse(self.network.set_tags.called)
self.assertIsNone(result)
def _test_unset_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['green']
else:
arglist = ['--all-tag']
verifylist = [('all_tag', True)]
expected_args = []
arglist.append(self._network.name)
verifylist.append(
('network', self._network.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_network.called)
self.network.set_tags.assert_called_once_with(
self._network,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_unset_with_tags(self):
self._test_unset_tags(with_tags=True)
def test_unset_with_all_tag(self):
self._test_unset_tags(with_tags=False)

160
openstackclient/tests/unit/network/v2/test_port.py
View File

@ -21,7 +21,6 @@ from osc_lib import utils
from openstackclient.network.v2 import port
from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes
from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
from openstackclient.tests.unit.network.v2 import _test_tag
from openstackclient.tests.unit.network.v2 import fakes as network_fakes
from openstackclient.tests.unit import utils as tests_utils
@ -97,7 +96,7 @@ class TestPort(network_fakes.TestNetworkV2):
return columns, data
class TestCreatePort(TestPort, _test_tag.TestCreateTagMixin):
class TestCreatePort(TestPort):
_port = network_fakes.FakePort.create_one_port()
columns, data = TestPort._get_common_cols_data(_port)
@ -116,24 +115,6 @@ class TestCreatePort(TestPort, _test_tag.TestCreateTagMixin):
# Get the command object to test
self.cmd = port.CreatePort(self.app, self.namespace)
# TestUnsetTagMixin
self._tag_test_resource = self._port
self._tag_create_resource_mock = self.network.create_port
self._tag_create_required_arglist = [
'--network', self._port.network_id,
'test-port',
]
self._tag_create_required_verifylist = [
('network', self._port.network_id,),
('enable', True),
('name', 'test-port'),
]
self._tag_create_required_attrs = {
'admin_state_up': True,
'network_id': self._port.network_id,
'name': 'test-port',
}
def test_create_default_options(self):
arglist = [
'--network', self._port.network_id,
@ -517,6 +498,48 @@ class TestCreatePort(TestPort, _test_tag.TestCreateTagMixin):
'name': 'test-port',
})
def _test_create_with_tag(self, add_tags=True):
arglist = [
'--network', self._port.network_id,
'test-port',
]
if add_tags:
arglist += ['--tag', 'red', '--tag', 'blue']
else:
arglist += ['--no-tag']
verifylist = [
('network', self._port.network_id,),
('enable', True),
('name', 'test-port'),
]
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_port.assert_called_once_with(
admin_state_up=True,
network_id=self._port.network_id,
name='test-port'
)
if add_tags:
self.network.set_tags.assert_called_once_with(
self._port,
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)
class TestDeletePort(TestPort):
@ -597,7 +620,7 @@ class TestDeletePort(TestPort):
)
class TestListPort(TestPort, _test_tag.TestListTagMixin):
class TestListPort(TestPort):
_ports = network_fakes.FakePort.create_ports(count=3)
@ -658,8 +681,6 @@ class TestListPort(TestPort, _test_tag.TestListTagMixin):
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()
# TestUnsetTagMixin
self._tag_list_resource_mock = self.network.ports
def test_port_list_no_options(self):
arglist = []
@ -919,8 +940,33 @@ class TestListPort(TestPort, _test_tag.TestListTagMixin):
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)
class TestSetPort(TestPort, _test_tag.TestSetTagMixin):
self.network.ports.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 TestSetPort(TestPort):
_port = network_fakes.FakePort.create_one_port({'tags': ['green', 'red']})
@ -934,10 +980,6 @@ class TestSetPort(TestPort, _test_tag.TestSetTagMixin):
# Get the command object to test
self.cmd = port.SetPort(self.app, self.namespace)
# TestSetTagMixin
self._tag_resource_name = 'port'
self._tag_test_resource = self._port
self._tag_update_resource_mock = self.network.update_port
def test_set_port_defaults(self):
arglist = [
@ -1430,6 +1472,34 @@ class TestSetPort(TestPort, _test_tag.TestSetTagMixin):
arglist,
None)
def _test_set_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['red', 'blue', 'green']
else:
arglist = ['--no-tag']
verifylist = [('no_tag', True)]
expected_args = []
arglist.append(self._port.name)
verifylist.append(
('port', self._port.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_port.called)
self.network.set_tags.assert_called_once_with(
self._port,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_set_with_tags(self):
self._test_set_tags(with_tags=True)
def test_set_with_no_tag(self):
self._test_set_tags(with_tags=False)
class TestShowPort(TestPort):
@ -1470,7 +1540,7 @@ class TestShowPort(TestPort):
self.assertEqual(self.data, data)
class TestUnsetPort(TestPort, _test_tag.TestUnsetTagMixin):
class TestUnsetPort(TestPort):
def setUp(self):
super(TestUnsetPort, self).setUp()
@ -1489,10 +1559,6 @@ class TestUnsetPort(TestPort, _test_tag.TestUnsetTagMixin):
self.network.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = port.UnsetPort(self.app, self.namespace)
# TestUnsetTagMixin
self._tag_resource_name = 'port'
self._tag_test_resource = self._testport
self._tag_update_resource_mock = self.network.update_port
def test_unset_port_parameters(self):
arglist = [
@ -1661,3 +1727,31 @@ class TestUnsetPort(TestPort, _test_tag.TestUnsetTagMixin):
self.network.update_port.assert_called_once_with(_fake_port, **attrs)
self.assertIsNone(result)
def _test_unset_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['green']
else:
arglist = ['--all-tag']
verifylist = [('all_tag', True)]
expected_args = []
arglist.append(self._testport.name)
verifylist.append(
('port', self._testport.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_port.called)
self.network.set_tags.assert_called_once_with(
self._testport,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_unset_with_tags(self):
self._test_unset_tags(with_tags=True)
def test_unset_with_all_tag(self):
self._test_unset_tags(with_tags=False)

156
openstackclient/tests/unit/network/v2/test_router.py
View File

@ -19,7 +19,6 @@ from osc_lib import utils as osc_utils
from openstackclient.network.v2 import router
from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
from openstackclient.tests.unit.network.v2 import _test_tag
from openstackclient.tests.unit.network.v2 import fakes as network_fakes
from openstackclient.tests.unit import utils as tests_utils
@ -112,7 +111,7 @@ class TestAddSubnetToRouter(TestRouter):
self.assertIsNone(result)
class TestCreateRouter(TestRouter, _test_tag.TestCreateTagMixin):
class TestCreateRouter(TestRouter):
# The new router created.
new_router = network_fakes.FakeRouter.create_one_router()
@ -157,23 +156,6 @@ class TestCreateRouter(TestRouter, _test_tag.TestCreateTagMixin):
# Get the command object to test
self.cmd = router.CreateRouter(self.app, self.namespace)
# TestCreateTagMixin
self._tag_test_resource = self.new_router
self._tag_create_resource_mock = self.network.create_router
self._tag_create_required_arglist = [
self.new_router.name,
]
self._tag_create_required_verifylist = [
('name', self.new_router.name),
('enable', True),
('distributed', False),
('ha', False),
]
self._tag_create_required_attrs = {
'admin_state_up': True,
'name': self.new_router.name,
}
def test_create_no_options(self):
arglist = []
verifylist = []
@ -288,6 +270,45 @@ class TestCreateRouter(TestRouter, _test_tag.TestCreateTagMixin):
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)
class TestDeleteRouter(TestRouter):
@ -368,7 +389,7 @@ class TestDeleteRouter(TestRouter):
)
class TestListRouter(TestRouter, _test_tag.TestListTagMixin):
class TestListRouter(TestRouter):
# The routers going to be listed up.
routers = network_fakes.FakeRouter.create_routers(count=3)
@ -459,9 +480,6 @@ class TestListRouter(TestRouter, _test_tag.TestListTagMixin):
self.network.get_agent = mock.Mock(return_value=self._testagent)
self.network.get_router = mock.Mock(return_value=self.routers[0])
# TestListTagMixin
self._tag_list_resource_mock = self.network.routers
def test_router_list_no_options(self):
arglist = []
verifylist = [
@ -636,6 +654,31 @@ class TestListRouter(TestRouter, _test_tag.TestListTagMixin):
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 TestRemovePortFromRouter(TestRouter):
'''Remove port from a Router '''
@ -714,7 +757,7 @@ class TestRemoveSubnetFromRouter(TestRouter):
self.assertIsNone(result)
class TestSetRouter(TestRouter, _test_tag.TestSetTagMixin):
class TestSetRouter(TestRouter):
# The router to set.
_default_route = {'destination': '10.20.20.0/24', 'nexthop': '10.20.30.1'}
@ -736,11 +779,6 @@ class TestSetRouter(TestRouter, _test_tag.TestSetTagMixin):
# Get the command object to test
self.cmd = router.SetRouter(self.app, self.namespace)
# TestSetTagMixin
self._tag_resource_name = 'router'
self._tag_test_resource = self._router
self._tag_update_resource_mock = self.network.update_router
def test_set_this(self):
arglist = [
self._router.name,
@ -1047,6 +1085,34 @@ class TestSetRouter(TestRouter, _test_tag.TestSetTagMixin):
'enable_snat': True, }})
self.assertIsNone(result)
def _test_set_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['red', 'blue', 'green']
else:
arglist = ['--no-tag']
verifylist = [('no_tag', True)]
expected_args = []
arglist.append(self._router.name)
verifylist.append(
('router', self._router.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_router.called)
self.network.set_tags.assert_called_once_with(
self._router,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_set_with_tags(self):
self._test_set_tags(with_tags=True)
def test_set_with_no_tag(self):
self._test_set_tags(with_tags=False)
class TestShowRouter(TestRouter):
@ -1132,10 +1198,6 @@ class TestUnsetRouter(TestRouter):
self.network.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = router.UnsetRouter(self.app, self.namespace)
# TestUnsetTagMixin
self._tag_resource_name = 'router'
self._tag_test_resource = self._testrouter
self._tag_update_resource_mock = self.network.update_router
def test_unset_router_params(self):
arglist = [
@ -1184,3 +1246,31 @@ class TestUnsetRouter(TestRouter):
self.network.update_router.assert_called_once_with(
self._testrouter, **attrs)
self.assertIsNone(result)
def _test_unset_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['green']
else:
arglist = ['--all-tag']
verifylist = [('all_tag', True)]
expected_args = []
arglist.append(self._testrouter.name)
verifylist.append(
('router', self._testrouter.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_router.called)
self.network.set_tags.assert_called_once_with(
self._testrouter,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_unset_with_tags(self):
self._test_unset_tags(with_tags=True)
def test_unset_with_all_tag(self):
self._test_unset_tags(with_tags=False)

168
openstackclient/tests/unit/network/v2/test_subnet.py
View File

@ -19,7 +19,6 @@ from osc_lib import utils
from openstackclient.network.v2 import subnet as subnet_v2
from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
from openstackclient.tests.unit.network.v2 import _test_tag
from openstackclient.tests.unit.network.v2 import fakes as network_fakes
from openstackclient.tests.unit import utils as tests_utils
@ -37,7 +36,7 @@ class TestSubnet(network_fakes.TestNetworkV2):
self.domains_mock = self.app.client_manager.identity.domains
class TestCreateSubnet(TestSubnet, _test_tag.TestCreateTagMixin):
class TestCreateSubnet(TestSubnet):
project = identity_fakes_v3.FakeProject.create_one_project()
domain = identity_fakes_v3.FakeDomain.create_one_domain()
@ -212,28 +211,6 @@ class TestCreateSubnet(TestSubnet, _test_tag.TestCreateTagMixin):
return_value=self._subnet_pool
)
# TestUnsetTagMixin
self._tag_test_resource = self._subnet
self._tag_create_resource_mock = self.network.create_subnet
self._tag_create_required_arglist = [
"--subnet-range", self._subnet.cidr,
"--network", self._subnet.network_id,
self._subnet.name,
]
self._tag_create_required_verifylist = [
('name', self._subnet.name),
('subnet_range', self._subnet.cidr),
('network', self._subnet.network_id),
('ip_version', self._subnet.ip_version),
('gateway', 'auto'),
]
self._tag_create_required_attrs = {
'cidr': self._subnet.cidr,
'ip_version': self._subnet.ip_version,
'name': self._subnet.name,
'network_id': self._subnet.network_id,
}
def test_create_no_options(self):
arglist = []
verifylist = []
@ -478,6 +455,51 @@ class TestCreateSubnet(TestSubnet, _test_tag.TestCreateTagMixin):
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def _test_create_with_tag(self, add_tags=True):
arglist = [
"--subnet-range", self._subnet.cidr,
"--network", self._subnet.network_id,
self._subnet.name,
]
if add_tags:
arglist += ['--tag', 'red', '--tag', 'blue']
else:
arglist += ['--no-tag']
verifylist = [
('name', self._subnet.name),
('subnet_range', self._subnet.cidr),
('network', self._subnet.network_id),
('ip_version', self._subnet.ip_version),
('gateway', 'auto'),
]
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_subnet.assert_called_once_with(
cidr=self._subnet.cidr,
ip_version=self._subnet.ip_version,
name=self._subnet.name,
network_id=self._subnet.network_id)
if add_tags:
self.network.set_tags.assert_called_once_with(
self._subnet,
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)
class TestDeleteSubnet(TestSubnet):
@ -558,7 +580,7 @@ class TestDeleteSubnet(TestSubnet):
)
class TestListSubnet(TestSubnet, _test_tag.TestListTagMixin):
class TestListSubnet(TestSubnet):
# The subnets going to be listed up.
_subnet = network_fakes.FakeSubnet.create_subnets(count=3)
@ -615,9 +637,6 @@ class TestListSubnet(TestSubnet, _test_tag.TestListTagMixin):
self.network.subnets = mock.Mock(return_value=self._subnet)
# TestUnsetTagMixin
self._tag_list_resource_mock = self.network.subnets
def test_subnet_list_no_options(self):
arglist = []
verifylist = [
@ -837,8 +856,33 @@ class TestListSubnet(TestSubnet, _test_tag.TestListTagMixin):
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)
class TestSetSubnet(TestSubnet, _test_tag.TestSetTagMixin):
self.network.subnets.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 TestSetSubnet(TestSubnet):
_subnet = network_fakes.FakeSubnet.create_one_subnet(
{'tags': ['green', 'red']})
@ -849,10 +893,6 @@ class TestSetSubnet(TestSubnet, _test_tag.TestSetTagMixin):
self.network.set_tags = mock.Mock(return_value=None)
self.network.find_subnet = mock.Mock(return_value=self._subnet)
self.cmd = subnet_v2.SetSubnet(self.app, self.namespace)
# TestSetTagMixin
self._tag_resource_name = 'subnet'
self._tag_test_resource = self._subnet
self._tag_update_resource_mock = self.network.update_subnet
def test_set_this(self):
arglist = [
@ -1001,6 +1041,34 @@ class TestSetSubnet(TestSubnet, _test_tag.TestSetTagMixin):
_testsubnet, **attrs)
self.assertIsNone(result)
def _test_set_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['red', 'blue', 'green']
else:
arglist = ['--no-tag']
verifylist = [('no_tag', True)]
expected_args = []
arglist.append(self._subnet.name)
verifylist.append(
('subnet', self._subnet.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_subnet.called)
self.network.set_tags.assert_called_once_with(
self._subnet,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_set_with_tags(self):
self._test_set_tags(with_tags=True)
def test_set_with_no_tag(self):
self._test_set_tags(with_tags=False)
class TestShowSubnet(TestSubnet):
# The subnets to be shown
@ -1083,7 +1151,7 @@ class TestShowSubnet(TestSubnet):
self.assertEqual(self.data, data)
class TestUnsetSubnet(TestSubnet, _test_tag.TestUnsetTagMixin):
class TestUnsetSubnet(TestSubnet):
def setUp(self):
super(TestUnsetSubnet, self).setUp()
@ -1106,10 +1174,6 @@ class TestUnsetSubnet(TestSubnet, _test_tag.TestUnsetTagMixin):
self.network.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = subnet_v2.UnsetSubnet(self.app, self.namespace)
# TestUnsetTagMixin
self._tag_resource_name = 'subnet'
self._tag_test_resource = self._testsubnet
self._tag_update_resource_mock = self.network.update_subnet
def test_unset_subnet_params(self):
arglist = [
@ -1219,3 +1283,31 @@ class TestUnsetSubnet(TestSubnet, _test_tag.TestUnsetTagMixin):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(exceptions.CommandError,
self.cmd.take_action, parsed_args)
def _test_unset_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['green']
else:
arglist = ['--all-tag']
verifylist = [('all_tag', True)]
expected_args = []
arglist.append(self._testsubnet.name)
verifylist.append(
('subnet', self._testsubnet.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_subnet.called)
self.network.set_tags.assert_called_once_with(
self._testsubnet,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_unset_with_tags(self):
self._test_unset_tags(with_tags=True)
def test_unset_with_all_tag(self):
self._test_unset_tags(with_tags=False)

159
openstackclient/tests/unit/network/v2/test_subnet_pool.py
View File

@ -20,7 +20,6 @@ from osc_lib import utils
from openstackclient.network.v2 import subnet_pool
from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
from openstackclient.tests.unit.network.v2 import _test_tag
from openstackclient.tests.unit.network.v2 import fakes as network_fakes
from openstackclient.tests.unit import utils as tests_utils
@ -38,7 +37,7 @@ class TestSubnetPool(network_fakes.TestNetworkV2):
self.domains_mock = self.app.client_manager.identity.domains
class TestCreateSubnetPool(TestSubnetPool, _test_tag.TestCreateTagMixin):
class TestCreateSubnetPool(TestSubnetPool):
project = identity_fakes_v3.FakeProject.create_one_project()
domain = identity_fakes_v3.FakeDomain.create_one_domain()
@ -96,22 +95,6 @@ class TestCreateSubnetPool(TestSubnetPool, _test_tag.TestCreateTagMixin):
self.projects_mock.get.return_value = self.project
self.domains_mock.get.return_value = self.domain
# TestUnsetTagMixin
self._tag_test_resource = self._subnet_pool
self._tag_create_resource_mock = self.network.create_subnet_pool
self._tag_create_required_arglist = [
'--pool-prefix', '10.0.10.0/24',
self._subnet_pool.name,
]
self._tag_create_required_verifylist = [
('prefixes', ['10.0.10.0/24']),
('name', self._subnet_pool.name),
]
self._tag_create_required_attrs = {
'prefixes': ['10.0.10.0/24'],
'name': self._subnet_pool.name,
}
def test_create_no_options(self):
arglist = []
verifylist = []
@ -313,6 +296,46 @@ class TestCreateSubnetPool(TestSubnetPool, _test_tag.TestCreateTagMixin):
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
def _test_create_with_tag(self, add_tags=True):
arglist = [
'--pool-prefix', '10.0.10.0/24',
self._subnet_pool.name,
]
if add_tags:
arglist += ['--tag', 'red', '--tag', 'blue']
else:
arglist += ['--no-tag']
verifylist = [
('prefixes', ['10.0.10.0/24']),
('name', self._subnet_pool.name),
]
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_subnet_pool.assert_called_once_with(
prefixes=['10.0.10.0/24'],
name=self._subnet_pool.name
)
if add_tags:
self.network.set_tags.assert_called_once_with(
self._subnet_pool,
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)
class TestDeleteSubnetPool(TestSubnetPool):
@ -396,7 +419,7 @@ class TestDeleteSubnetPool(TestSubnetPool):
)
class TestListSubnetPool(TestSubnetPool, _test_tag.TestListTagMixin):
class TestListSubnetPool(TestSubnetPool):
# The subnet pools going to be listed up.
_subnet_pools = network_fakes.FakeSubnetPool.create_subnet_pools(count=3)
@ -442,9 +465,6 @@ class TestListSubnetPool(TestSubnetPool, _test_tag.TestListTagMixin):
self.network.subnet_pools = mock.Mock(return_value=self._subnet_pools)
# TestUnsetTagMixin
self._tag_list_resource_mock = self.network.subnet_pools
def test_subnet_pool_list_no_option(self):
arglist = []
verifylist = [
@ -611,8 +631,33 @@ class TestListSubnetPool(TestSubnetPool, _test_tag.TestListTagMixin):
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)
class TestSetSubnetPool(TestSubnetPool, _test_tag.TestSetTagMixin):
self.network.subnet_pools.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 TestSetSubnetPool(TestSubnetPool):
# The subnet_pool to set.
_subnet_pool = network_fakes.FakeSubnetPool.create_one_subnet_pool(
@ -637,11 +682,6 @@ class TestSetSubnetPool(TestSubnetPool, _test_tag.TestSetTagMixin):
# Get the command object to test
self.cmd = subnet_pool.SetSubnetPool(self.app, self.namespace)
# TestUnsetTagMixin
self._tag_resource_name = 'subnet_pool'
self._tag_test_resource = self._subnet_pool
self._tag_update_resource_mock = self.network.update_subnet_pool
def test_set_this(self):
arglist = [
'--name', 'noob',
@ -867,6 +907,34 @@ class TestSetSubnetPool(TestSubnetPool, _test_tag.TestSetTagMixin):
)
self.assertIsNone(result)
def _test_set_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['red', 'blue', 'green']
else:
arglist = ['--no-tag']
verifylist = [('no_tag', True)]
expected_args = []
arglist.append(self._subnet_pool.name)
verifylist.append(
('subnet_pool', self._subnet_pool.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_subnet_pool.called)
self.network.set_tags.assert_called_once_with(
self._subnet_pool,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_set_with_tags(self):
self._test_set_tags(with_tags=True)
def test_set_with_no_tag(self):
self._test_set_tags(with_tags=False)
class TestShowSubnetPool(TestSubnetPool):
@ -943,7 +1011,7 @@ class TestShowSubnetPool(TestSubnetPool):
self.assertEqual(self.data, data)
class TestUnsetSubnetPool(TestSubnetPool, _test_tag.TestUnsetTagMixin):
class TestUnsetSubnetPool(TestSubnetPool):
def setUp(self):
super(TestUnsetSubnetPool, self).setUp()
@ -958,11 +1026,6 @@ class TestUnsetSubnetPool(TestSubnetPool, _test_tag.TestUnsetTagMixin):
# Get the command object to test
self.cmd = subnet_pool.UnsetSubnetPool(self.app, self.namespace)
# TestUnsetTagMixin
self._tag_resource_name = 'subnet_pool'
self._tag_test_resource = self._subnetpool
self._tag_update_resource_mock = self.network.update_subnet_pool
def test_unset_subnet_pool(self):
arglist = [
'--pool-prefix', '10.0.10.0/24',
@ -993,3 +1056,31 @@ class TestUnsetSubnetPool(TestSubnetPool, _test_tag.TestUnsetTagMixin):
self.assertRaises(exceptions.CommandError,
self.cmd.take_action,
parsed_args)
def _test_unset_tags(self, with_tags=True):
if with_tags:
arglist = ['--tag', 'red', '--tag', 'blue']
verifylist = [('tags', ['red', 'blue'])]
expected_args = ['green']
else:
arglist = ['--all-tag']
verifylist = [('all_tag', True)]
expected_args = []
arglist.append(self._subnetpool.name)
verifylist.append(
('subnet_pool', self._subnetpool.name))
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_subnet_pool.called)
self.network.set_tags.assert_called_once_with(
self._subnetpool,
tests_utils.CompareBySet(expected_args))
self.assertIsNone(result)
def test_unset_with_tags(self):
self._test_unset_tags(with_tags=True)
def test_unset_with_all_tag(self):
self._test_unset_tags(with_tags=False)