openstack/python-openstackclient
Code Issues Proposed changes

tests: Use consistent shortcut to fake network client

Browse Source 
This removes the need for a number of base test case subclasses. We use
'network_client' rather than 'network' for consistency with other
services.

Change-Id: I61f7c43341acf19ae16d06db34e18970297fbb93
Signed-off-by: Stephen Finucane <stephenfin@redhat.com>
This commit is contained in:
Stephen Finucane 2023-08-25 13:38:32 +01:00
parent 84dd5b0018
commit b25742499a
35 changed files with 1640 additions and 1303 deletions

1
openstackclient/tests/unit/common/test_extension.py

@ -46,7 +46,6 @@ class TestExtension(utils.TestCommand):
self.app.client_manager.network = mock.Mock()
self.network_client = self.app.client_manager.network
self.network_client.extensions = mock.Mock()
class TestExtensionList(TestExtension):

69
openstackclient/tests/unit/common/test_quota.py

@ -63,7 +63,7 @@ class TestQuota(compute_fakes.TestComputev2):
self.volume_quotas_class_mock.reset_mock()
self.app.client_manager.network = mock.Mock()
self.network_mock = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.app.client_manager.auth_ref = mock.Mock()
self.app.client_manager.auth_ref.service_catalog = mock.Mock()
@ -158,8 +158,7 @@ class TestQuotaList(TestQuota):
network_fakes.FakeQuota.create_one_default_net_quota(),
network_fakes.FakeQuota.create_one_default_net_quota(),
]
self.network = self.app.client_manager.network
self.network.get_quota_default = mock.Mock(
self.network_client.get_quota_default = mock.Mock(
side_effect=self.network_default_quotas,
)
@ -261,7 +260,7 @@ class TestQuotaList(TestQuota):
detailed_quota
)
self.network.get_quota = mock.Mock(return_value=detailed_quota)
self.network_client.get_quota = mock.Mock(return_value=detailed_quota)
arglist = [
'--detail',
@ -452,7 +451,7 @@ class TestQuotaList(TestQuota):
def test_quota_list_network(self):
# Two projects with non-default quotas
self.network.get_quota = mock.Mock(
self.network_client.get_quota = mock.Mock(
side_effect=self.network_quotas,
)
@ -473,7 +472,7 @@ class TestQuotaList(TestQuota):
def test_quota_list_network_default(self):
# Two projects with non-default quotas
self.network.get_quota = mock.Mock(
self.network_client.get_quota = mock.Mock(
side_effect=[
self.network_quotas[0],
network_fakes.FakeQuota.create_one_default_net_quota(),
@ -497,7 +496,7 @@ class TestQuotaList(TestQuota):
def test_quota_list_network_no_project(self):
# Two projects with non-default quotas
self.network.get_quota = mock.Mock(
self.network_client.get_quota = mock.Mock(
side_effect=[
self.network_quotas[0],
exceptions.NotFound("NotFound"),
@ -521,7 +520,7 @@ class TestQuotaList(TestQuota):
def test_quota_list_network_by_project(self):
# Two projects with non-default quotas
self.network.get_quota = mock.Mock(
self.network_client.get_quota = mock.Mock(
side_effect=self.network_quotas,
)
@ -663,7 +662,7 @@ class TestQuotaSet(TestQuota):
loaded=True,
)
self.network_mock.update_quota = mock.Mock()
self.network_client.update_quota = mock.Mock()
self.cmd = quota.SetQuota(self.app, None)
@ -893,7 +892,7 @@ class TestQuotaSet(TestQuota):
'rbac_policy': network_fakes.QUOTA['rbac_policy'],
'port': network_fakes.QUOTA['port'],
}
self.network_mock.update_quota.assert_called_once_with(
self.network_client.update_quota.assert_called_once_with(
self.projects[0].id, **kwargs
)
self.assertIsNone(result)
@ -980,7 +979,7 @@ class TestQuotaSet(TestQuota):
self.volume_quotas_class_mock.update.assert_called_with(
self.projects[0].name, **kwargs_volume
)
self.assertNotCalled(self.network_mock.update_quota)
self.assertNotCalled(self.network_client.update_quota)
self.assertIsNone(result)
def test_quota_set_with_force(self):
@ -1031,7 +1030,7 @@ class TestQuotaSet(TestQuota):
self.volume_quotas_mock.update.assert_called_once_with(
self.projects[0].id, **kwargs_volume
)
self.network_mock.update_quota.assert_called_once_with(
self.network_client.update_quota.assert_called_once_with(
self.projects[0].id, **kwargs_network
)
self.assertIsNone(result)
@ -1075,7 +1074,7 @@ class TestQuotaSet(TestQuota):
self.volume_quotas_mock.update.assert_called_once_with(
self.projects[0].id, **kwargs_volume
)
self.network_mock.update_quota.assert_called_once_with(
self.network_client.update_quota.assert_called_once_with(
self.projects[0].id, **kwargs_network
)
self.assertIsNone(result)
@ -1121,12 +1120,10 @@ class TestQuotaShow(TestQuota):
'network': fake_network_endpoint
}
self.app.client_manager.network = mock.Mock()
self.network = self.app.client_manager.network
self.network.get_quota = mock.Mock(
self.network_client.get_quota = mock.Mock(
return_value=network_fakes.QUOTA,
)
self.network.get_quota_default = mock.Mock(
self.network_client.get_quota_default = mock.Mock(
return_value=network_fakes.QUOTA,
)
@ -1152,11 +1149,11 @@ class TestQuotaShow(TestQuota):
self.projects[0].id,
usage=False,
)
self.network.get_quota.assert_called_once_with(
self.network_client.get_quota.assert_called_once_with(
self.projects[0].id,
details=False,
)
self.assertNotCalled(self.network.get_quota_default)
self.assertNotCalled(self.network_client.get_quota_default)
def test_quota_show__with_compute(self):
arglist = [
@ -1176,7 +1173,7 @@ class TestQuotaShow(TestQuota):
detail=False,
)
self.volume_quotas_mock.get.assert_not_called()
self.network.get_quota.assert_not_called()
self.network_client.get_quota.assert_not_called()
def test_quota_show__with_volume(self):
arglist = [
@ -1196,7 +1193,7 @@ class TestQuotaShow(TestQuota):
self.projects[0].id,
usage=False,
)
self.network.get_quota.assert_not_called()
self.network_client.get_quota.assert_not_called()
def test_quota_show__with_network(self):
arglist = [
@ -1213,11 +1210,11 @@ class TestQuotaShow(TestQuota):
self.compute_quotas_mock.get.assert_not_called()
self.volume_quotas_mock.get.assert_not_called()
self.network.get_quota.assert_called_once_with(
self.network_client.get_quota.assert_called_once_with(
self.projects[0].id,
details=False,
)
self.assertNotCalled(self.network.get_quota_default)
self.assertNotCalled(self.network_client.get_quota_default)
def test_quota_show__with_default(self):
arglist = [
@ -1238,10 +1235,10 @@ class TestQuotaShow(TestQuota):
self.volume_quotas_mock.defaults.assert_called_once_with(
self.projects[0].id,
)
self.network.get_quota_default.assert_called_once_with(
self.network_client.get_quota_default.assert_called_once_with(
self.projects[0].id,
)
self.assertNotCalled(self.network.get_quota)
self.assertNotCalled(self.network_client.get_quota)
def test_quota_show__with_class(self):
arglist = [
@ -1259,8 +1256,8 @@ class TestQuotaShow(TestQuota):
self.compute_quotas_class_mock.get.assert_called_once_with('default')
self.volume_quotas_class_mock.get.assert_called_once_with('default')
# neutron doesn't have the concept of quota classes
self.assertNotCalled(self.network.get_quota)
self.assertNotCalled(self.network.get_quota_default)
self.assertNotCalled(self.network_client.get_quota)
self.assertNotCalled(self.network_client.get_quota_default)
def test_quota_show__with_usage(self):
# update mocks to return detailed quota instead
@ -1268,7 +1265,7 @@ class TestQuotaShow(TestQuota):
self.compute_quotas_mock.get.return_value = self.compute_quota
self.volume_quota = volume_fakes.create_one_detailed_quota()
self.volume_quotas_mock.get.return_value = self.volume_quota
self.network.get_quota.return_value = (
self.network_client.get_quota.return_value = (
network_fakes.FakeQuota.create_one_net_detailed_quota()
)
@ -1292,7 +1289,7 @@ class TestQuotaShow(TestQuota):
self.projects[0].id,
usage=True,
)
self.network.get_quota.assert_called_once_with(
self.network_client.get_quota.assert_called_once_with(
self.projects[0].id,
details=True,
)
@ -1312,10 +1309,10 @@ class TestQuotaShow(TestQuota):
self.volume_quotas_mock.get.assert_called_once_with(
identity_fakes.project_id, usage=False
)
self.network.get_quota.assert_called_once_with(
self.network_client.get_quota.assert_called_once_with(
identity_fakes.project_id, details=False
)
self.assertNotCalled(self.network.get_quota_default)
self.assertNotCalled(self.network_client.get_quota_default)
class TestQuotaDelete(TestQuota):
@ -1324,7 +1321,7 @@ class TestQuotaDelete(TestQuota):
def setUp(self):
super().setUp()
self.network_mock.delete_quota = mock.Mock()
self.network_client.delete_quota = mock.Mock()
self.cmd = quota.DeleteQuota(self.app, None)
@ -1350,7 +1347,7 @@ class TestQuotaDelete(TestQuota):
self.volume_quotas_mock.delete.assert_called_once_with(
self.projects[0].id,
)
self.network_mock.delete_quota.assert_called_once_with(
self.network_client.delete_quota.assert_called_once_with(
self.projects[0].id,
)
@ -1375,7 +1372,7 @@ class TestQuotaDelete(TestQuota):
self.projects[0].id,
)
self.volume_quotas_mock.delete.assert_not_called()
self.network_mock.delete_quota.assert_not_called()
self.network_client.delete_quota.assert_not_called()
def test_delete__volume(self):
"""Delete volume quotas only"""
@ -1398,7 +1395,7 @@ class TestQuotaDelete(TestQuota):
self.volume_quotas_mock.delete.assert_called_once_with(
self.projects[0].id,
)
self.network_mock.delete_quota.assert_not_called()
self.network_client.delete_quota.assert_not_called()
def test_delete__network(self):
"""Delete network quotas only"""
@ -1419,6 +1416,6 @@ class TestQuotaDelete(TestQuota):
self.projects_mock.get.assert_called_once_with(self.projects[0].id)
self.compute_quotas_mock.delete.assert_not_called()
self.volume_quotas_mock.delete.assert_not_called()
self.network_mock.delete_quota.assert_called_once_with(
self.network_client.delete_quota.assert_called_once_with(
self.projects[0].id,
)

111
openstackclient/tests/unit/compute/v2/test_server.py

@ -113,6 +113,9 @@ class TestServer(compute_fakes.TestComputev2):
self.snapshots_mock = self.app.client_manager.volume.volume_snapshots
self.snapshots_mock.reset_mock()
self.app.client_manager.network = mock.Mock()
self.network_client = self.app.client_manager.network
# Set object attributes to be tested. Could be overwritten in subclass.
self.attrs = {}
@ -522,9 +525,7 @@ class TestServerAddFloatingIPNetwork(
def setUp(self):
super(TestServerAddFloatingIPNetwork, self).setUp()
self.app.client_manager.network = mock.Mock()
self.network = self.app.client_manager.network
self.network.update_ip = mock.Mock(return_value=None)
self.network_client.update_ip = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = server.AddFloatingIP(self.app, self.namespace)
@ -534,8 +535,8 @@ class TestServerAddFloatingIPNetwork(
self.servers_mock.get.return_value = _server
_port = network_fakes.create_one_port()
_floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
self.network.find_ip = mock.Mock(return_value=_floating_ip)
self.network.ports = mock.Mock(return_value=[_port])
self.network_client.find_ip = mock.Mock(return_value=_floating_ip)
self.network_client.ports = mock.Mock(return_value=[_port])
arglist = [
_server.id,
_floating_ip['floating_ip_address'],
@ -552,22 +553,24 @@ class TestServerAddFloatingIPNetwork(
'port_id': _port.id,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
_floating_ip['floating_ip_address'],
ignore_missing=False,
)
self.network.ports.assert_called_once_with(
self.network_client.ports.assert_called_once_with(
device_id=_server.id,
)
self.network.update_ip.assert_called_once_with(_floating_ip, **attrs)
self.network_client.update_ip.assert_called_once_with(
_floating_ip, **attrs
)
def test_server_add_floating_ip_no_ports(self):
server = compute_fakes.create_one_server()
floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
self.servers_mock.get.return_value = server
self.network.find_ip = mock.Mock(return_value=floating_ip)
self.network.ports = mock.Mock(return_value=[])
self.network_client.find_ip = mock.Mock(return_value=floating_ip)
self.network_client.ports = mock.Mock(return_value=[])
arglist = [
server.id,
@ -586,11 +589,11 @@ class TestServerAddFloatingIPNetwork(
'No attached ports found to associate floating IP with', str(ex)
)
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
floating_ip['floating_ip_address'],
ignore_missing=False,
)
self.network.ports.assert_called_once_with(
self.network_client.ports.assert_called_once_with(
device_id=server.id,
)
@ -599,17 +602,17 @@ class TestServerAddFloatingIPNetwork(
self.servers_mock.get.return_value = _server
_port = network_fakes.create_one_port()
_floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
self.network.find_ip = mock.Mock(return_value=_floating_ip)
self.network_client.find_ip = mock.Mock(return_value=_floating_ip)
return_value = [_port]
# In the success case, we'll have two ports, where the first port is
# not attached to an external gateway but the second port is.
if success:
return_value.append(_port)
self.network.ports = mock.Mock(return_value=return_value)
self.network_client.ports = mock.Mock(return_value=return_value)
side_effect = [sdk_exceptions.NotFoundException()]
if success:
side_effect.append(None)
self.network.update_ip = mock.Mock(side_effect=side_effect)
self.network_client.update_ip = mock.Mock(side_effect=side_effect)
arglist = [
_server.id,
_floating_ip['floating_ip_address'],
@ -633,19 +636,19 @@ class TestServerAddFloatingIPNetwork(
'port_id': _port.id,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
_floating_ip['floating_ip_address'],
ignore_missing=False,
)
self.network.ports.assert_called_once_with(
self.network_client.ports.assert_called_once_with(
device_id=_server.id,
)
if success:
self.assertEqual(2, self.network.update_ip.call_count)
self.assertEqual(2, self.network_client.update_ip.call_count)
calls = [mock.call(_floating_ip, **attrs)] * 2
self.network.update_ip.assert_has_calls(calls)
self.network_client.update_ip.assert_has_calls(calls)
else:
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
_floating_ip, **attrs
)
@ -657,8 +660,8 @@ class TestServerAddFloatingIPNetwork(
self.servers_mock.get.return_value = _server
_port = network_fakes.create_one_port()
_floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
self.network.find_ip = mock.Mock(return_value=_floating_ip)
self.network.ports = mock.Mock(return_value=[_port])
self.network_client.find_ip = mock.Mock(return_value=_floating_ip)
self.network_client.ports = mock.Mock(return_value=[_port])
# The user has specified a fixed ip that matches one of the ports
# already attached to the instance.
arglist = [
@ -683,22 +686,24 @@ class TestServerAddFloatingIPNetwork(
'fixed_ip_address': _port.fixed_ips[0]['ip_address'],
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
_floating_ip['floating_ip_address'],
ignore_missing=False,
)
self.network.ports.assert_called_once_with(
self.network_client.ports.assert_called_once_with(
device_id=_server.id,
)
self.network.update_ip.assert_called_once_with(_floating_ip, **attrs)
self.network_client.update_ip.assert_called_once_with(
_floating_ip, **attrs
)
def test_server_add_floating_ip_with_fixed_ip_no_port_found(self):
_server = compute_fakes.create_one_server()
self.servers_mock.get.return_value = _server
_port = network_fakes.create_one_port()
_floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
self.network.find_ip = mock.Mock(return_value=_floating_ip)
self.network.ports = mock.Mock(return_value=[_port])
self.network_client.find_ip = mock.Mock(return_value=_floating_ip)
self.network_client.ports = mock.Mock(return_value=[_port])
# The user has specified a fixed ip that does not match any of the
# ports already attached to the instance.
nonexistent_ip = '10.0.0.9'
@ -719,14 +724,14 @@ class TestServerAddFloatingIPNetwork(
exceptions.CommandError, self.cmd.take_action, parsed_args
)
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
_floating_ip['floating_ip_address'],
ignore_missing=False,
)
self.network.ports.assert_called_once_with(
self.network_client.ports.assert_called_once_with(
device_id=_server.id,
)
self.network.update_ip.assert_not_called()
self.network_client.update_ip.assert_not_called()
class TestServerAddPort(TestServer):
@ -1699,19 +1704,16 @@ class TestServerCreate(TestServer):
get_endpoints
)
find_network = mock.Mock()
find_port = mock.Mock()
network_client = self.app.client_manager.network
network_client.find_network = find_network
network_client.find_port = find_port
network_resource = mock.Mock(id='net1_uuid')
port1_resource = mock.Mock(id='port1_uuid')
port2_resource = mock.Mock(id='port2_uuid')
find_network.return_value = network_resource
find_port.side_effect = lambda port_id, ignore_missing: {
"port1": port1_resource,
"port2": port2_resource,
}[port_id]
self.network_client.find_network.return_value = network_resource
self.network_client.find_port.side_effect = (
lambda port_id, ignore_missing: {
"port1": port1_resource,
"port2": port2_resource,
}[port_id]
)
# Mock sdk APIs.
_network_1 = mock.Mock(id='net1_uuid')
@ -1831,17 +1833,9 @@ class TestServerCreate(TestServer):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_network = mock.Mock()
network_client = self.app.client_manager.network
network_client.find_network = find_network
network_resource = mock.Mock(id='net1_uuid')
find_network.return_value = network_resource
# Mock sdk APIs.
_network = mock.Mock(id='net1_uuid')
find_network = mock.Mock()
find_network.return_value = _network
self.app.client_manager.network.find_network = find_network
self.network_client.find_network.return_value = _network
# In base command class ShowOne in cliff, abstract method take_action()
# returns a two-part tuple with a tuple of column names and a tuple of
@ -1881,7 +1875,7 @@ class TestServerCreate(TestServer):
self.assertEqual(self.columns, columns)
self.assertEqual(self.datalist(), data)
network_client.find_network.assert_called_once()
self.network_client.find_network.assert_called_once()
self.app.client_manager.network.find_network.assert_called_once()
def test_server_create_with_network_tag_pre_v243(self):
@ -2224,11 +2218,8 @@ class TestServerCreate(TestServer):
get_endpoints
)
find_port = mock.Mock()
network_client = self.app.client_manager.network
network_client.find_port = find_port
port_resource = mock.Mock(id='port1_uuid')
find_port.return_value = port_resource
self.network_client.find_port.return_value = port_resource
self.assertRaises(
exceptions.CommandError, self.cmd.take_action, parsed_args
@ -7265,8 +7256,8 @@ class TestServerRemoveFloatingIPNetwork(network_fakes.TestNetworkV2):
super(TestServerRemoveFloatingIPNetwork, self).setUp()
self.app.client_manager.network = mock.Mock()
self.network = self.app.client_manager.network
self.network.update_ip = mock.Mock(return_value=None)
self.network_client = self.app.client_manager.network
self.network_client.update_ip = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = server.RemoveFloatingIP(self.app, self.namespace)
@ -7274,7 +7265,7 @@ class TestServerRemoveFloatingIPNetwork(network_fakes.TestNetworkV2):
def test_server_remove_floating_ip_default(self):
_server = compute_fakes.create_one_server()
_floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
self.network.find_ip = mock.Mock(return_value=_floating_ip)
self.network_client.find_ip = mock.Mock(return_value=_floating_ip)
arglist = [
_server.id,
_floating_ip['ip'],
@ -7291,11 +7282,13 @@ class TestServerRemoveFloatingIPNetwork(network_fakes.TestNetworkV2):
'port_id': None,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
_floating_ip['ip'],
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(_floating_ip, **attrs)
self.network_client.update_ip.assert_called_once_with(
_floating_ip, **attrs
)
class TestServerRemovePort(TestServer):

22
openstackclient/tests/unit/network/test_common.py

@ -130,8 +130,8 @@ class TestNetworkAndCompute(utils.TestCommand):
# Create network client mocks.
self.app.client_manager.network = mock.Mock()
self.network = self.app.client_manager.network
self.network.network_action = mock.Mock(
self.network_client = self.app.client_manager.network
self.network_client.network_action = mock.Mock(
return_value='take_action_network'
)
@ -151,7 +151,7 @@ class TestNetworkAndCompute(utils.TestCommand):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.network_action.assert_called_with(parsed_args)
self.network_client.network_action.assert_called_with(parsed_args)
self.assertEqual('take_action_network', result)
def test_take_action_compute(self):
@ -210,8 +210,8 @@ class TestNeutronCommandWithExtraArgs(utils.TestCommand):
self.namespace = argparse.Namespace()
self.app.client_manager.network = mock.Mock()
self.network = self.app.client_manager.network
self.network.test_create_action = mock.Mock()
self.network_client = self.app.client_manager.network
self.network_client.test_create_action = mock.Mock()
# Subclasses can override the command object to test.
self.cmd = FakeCreateNeutronCommandWithExtraArgs(
@ -235,7 +235,7 @@ class TestNeutronCommandWithExtraArgs(utils.TestCommand):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.test_create_action.assert_called_with(
self.network_client.test_create_action.assert_called_with(
known_attribute='known-value', extra_name='extra_value'
)
@ -262,7 +262,7 @@ class TestNeutronCommandWithExtraArgs(utils.TestCommand):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.test_create_action.assert_called_with(
self.network_client.test_create_action.assert_called_with(
known_attribute='known-value', extra_name='extra_value'
)
@ -283,7 +283,7 @@ class TestNeutronCommandWithExtraArgs(utils.TestCommand):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.test_create_action.assert_called_with(
self.network_client.test_create_action.assert_called_with(
known_attribute='known-value', extra_name=True
)
@ -304,7 +304,7 @@ class TestNeutronCommandWithExtraArgs(utils.TestCommand):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.test_create_action.assert_called_with(
self.network_client.test_create_action.assert_called_with(
known_attribute='known-value', extra_name=8
)
@ -325,7 +325,7 @@ class TestNeutronCommandWithExtraArgs(utils.TestCommand):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.test_create_action.assert_called_with(
self.network_client.test_create_action.assert_called_with(
known_attribute='known-value', extra_name=['v_1', 'v_2']
)
@ -352,6 +352,6 @@ class TestNeutronCommandWithExtraArgs(utils.TestCommand):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.test_create_action.assert_called_with(
self.network_client.test_create_action.assert_called_with(
known_attribute='known-value', extra_name={'n1': 'v1', 'n2': 'v2'}
)

70
openstackclient/tests/unit/network/v2/test_address_group.py

@ -27,7 +27,7 @@ class TestAddressGroup(network_fakes.TestNetworkV2):
super(TestAddressGroup, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -60,7 +60,7 @@ class TestCreateAddressGroup(TestAddressGroup):
def setUp(self):
super(TestCreateAddressGroup, self).setUp()
self.network.create_address_group = mock.Mock(
self.network_client.create_address_group = mock.Mock(
return_value=self.new_address_group
)
@ -97,7 +97,7 @@ class TestCreateAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_address_group.assert_called_once_with(
self.network_client.create_address_group.assert_called_once_with(
**{
'name': self.new_address_group.name,
'addresses': [],
@ -129,7 +129,7 @@ class TestCreateAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_address_group.assert_called_once_with(
self.network_client.create_address_group.assert_called_once_with(
**{
'addresses': ['10.0.0.1/32'],
'project_id': self.project.id,
@ -147,9 +147,11 @@ class TestDeleteAddressGroup(TestAddressGroup):
def setUp(self):
super(TestDeleteAddressGroup, self).setUp()
self.network.delete_address_group = mock.Mock(return_value=None)
self.network.find_address_group = network_fakes.get_address_groups(
address_groups=self._address_groups
self.network_client.delete_address_group = mock.Mock(return_value=None)
self.network_client.find_address_group = (
network_fakes.get_address_groups(
address_groups=self._address_groups
)
)
# Get the command object to test
@ -166,10 +168,10 @@ class TestDeleteAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_address_group.assert_called_once_with(
self.network_client.find_address_group.assert_called_once_with(
self._address_groups[0].name, ignore_missing=False
)
self.network.delete_address_group.assert_called_once_with(
self.network_client.delete_address_group.assert_called_once_with(
self._address_groups[0]
)
self.assertIsNone(result)
@ -189,7 +191,7 @@ class TestDeleteAddressGroup(TestAddressGroup):
calls = []
for a in self._address_groups:
calls.append(call(a))
self.network.delete_address_group.assert_has_calls(calls)
self.network_client.delete_address_group.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_address_groups_delete_with_exception(self):
@ -206,7 +208,7 @@ class TestDeleteAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._address_groups[0], exceptions.CommandError]
self.network.find_address_group = mock.Mock(
self.network_client.find_address_group = mock.Mock(
side_effect=find_mock_result
)
@ -216,13 +218,13 @@ class TestDeleteAddressGroup(TestAddressGroup):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 address groups failed to delete.', str(e))
self.network.find_address_group.assert_any_call(
self.network_client.find_address_group.assert_any_call(
self._address_groups[0].name, ignore_missing=False
)
self.network.find_address_group.assert_any_call(
self.network_client.find_address_group.assert_any_call(
'unexist_address_group', ignore_missing=False
)
self.network.delete_address_group.assert_called_once_with(
self.network_client.delete_address_group.assert_called_once_with(
self._address_groups[0]
)
@ -251,7 +253,7 @@ class TestListAddressGroup(TestAddressGroup):
def setUp(self):
super(TestListAddressGroup, self).setUp()
self.network.address_groups = mock.Mock(
self.network_client.address_groups = mock.Mock(
return_value=self.address_groups
)
@ -265,7 +267,7 @@ class TestListAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_groups.assert_called_once_with(**{})
self.network_client.address_groups.assert_called_once_with(**{})
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -280,7 +282,7 @@ class TestListAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_groups.assert_called_once_with(
self.network_client.address_groups.assert_called_once_with(
**{'name': self.address_groups[0].name}
)
self.assertEqual(self.columns, columns)
@ -299,7 +301,7 @@ class TestListAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_groups.assert_called_once_with(
self.network_client.address_groups.assert_called_once_with(
project_id=project.id
)
self.assertEqual(self.columns, columns)
@ -320,7 +322,7 @@ class TestListAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_groups.assert_called_once_with(
self.network_client.address_groups.assert_called_once_with(
project_id=project.id
)
self.assertEqual(self.columns, columns)
@ -333,11 +335,11 @@ class TestSetAddressGroup(TestAddressGroup):
def setUp(self):
super(TestSetAddressGroup, self).setUp()
self.network.update_address_group = mock.Mock(return_value=None)
self.network.find_address_group = mock.Mock(
self.network_client.update_address_group = mock.Mock(return_value=None)
self.network_client.find_address_group = mock.Mock(
return_value=self._address_group
)
self.network.add_addresses_to_address_group = mock.Mock(
self.network_client.add_addresses_to_address_group = mock.Mock(
return_value=self._address_group
)
# Get the command object to test
@ -354,8 +356,8 @@ class TestSetAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_address_group.assert_not_called()
self.network.add_addresses_to_address_group.assert_not_called()
self.network_client.update_address_group.assert_not_called()
self.network_client.add_addresses_to_address_group.assert_not_called()
self.assertIsNone(result)
def test_set_name_and_description(self):
@ -378,7 +380,7 @@ class TestSetAddressGroup(TestAddressGroup):
'name': "new_address_group_name",
'description': 'new_address_group_description',
}
self.network.update_address_group.assert_called_with(
self.network_client.update_address_group.assert_called_with(
self._address_group, **attrs
)
self.assertIsNone(result)
@ -396,7 +398,7 @@ class TestSetAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.add_addresses_to_address_group.assert_called_once_with(
self.network_client.add_addresses_to_address_group.assert_called_once_with(
self._address_group, ['10.0.0.2/32']
)
self.assertIsNone(result)
@ -416,7 +418,7 @@ class TestSetAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.add_addresses_to_address_group.assert_called_once_with(
self.network_client.add_addresses_to_address_group.assert_called_once_with(
self._address_group, ['10.0.0.2/32', '2001::/16']
)
self.assertIsNone(result)
@ -442,7 +444,7 @@ class TestShowAddressGroup(TestAddressGroup):
def setUp(self):
super(TestShowAddressGroup, self).setUp()
self.network.find_address_group = mock.Mock(
self.network_client.find_address_group = mock.Mock(
return_value=self._address_group
)
@ -473,7 +475,7 @@ class TestShowAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_address_group.assert_called_once_with(
self.network_client.find_address_group.assert_called_once_with(
self._address_group.name, ignore_missing=False
)
self.assertEqual(self.columns, columns)
@ -486,10 +488,10 @@ class TestUnsetAddressGroup(TestAddressGroup):
def setUp(self):
super(TestUnsetAddressGroup, self).setUp()
self.network.find_address_group = mock.Mock(
self.network_client.find_address_group = mock.Mock(
return_value=self._address_group
)
self.network.remove_addresses_from_address_group = mock.Mock(
self.network_client.remove_addresses_from_address_group = mock.Mock(
return_value=self._address_group
)
# Get the command object to test
@ -506,7 +508,7 @@ class TestUnsetAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.remove_addresses_from_address_group.assert_not_called()
self.network_client.remove_addresses_from_address_group.assert_not_called()
self.assertIsNone(result)
def test_unset_one_address(self):
@ -522,7 +524,7 @@ class TestUnsetAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.remove_addresses_from_address_group.assert_called_once_with( # noqa: E501
self.network_client.remove_addresses_from_address_group.assert_called_once_with( # noqa: E501
self._address_group, ['10.0.0.2/32']
)
self.assertIsNone(result)
@ -542,7 +544,7 @@ class TestUnsetAddressGroup(TestAddressGroup):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.remove_addresses_from_address_group.assert_called_once_with( # noqa: E501
self.network_client.remove_addresses_from_address_group.assert_called_once_with( # noqa: E501
self._address_group, ['10.0.0.2/32', '2001::/16']
)
self.assertIsNone(result)

62
openstackclient/tests/unit/network/v2/test_address_scope.py

@ -27,7 +27,7 @@ class TestAddressScope(network_fakes.TestNetworkV2):
super(TestAddressScope, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -54,7 +54,7 @@ class TestCreateAddressScope(TestAddressScope):
def setUp(self):
super(TestCreateAddressScope, self).setUp()
self.network.create_address_scope = mock.Mock(
self.network_client.create_address_scope = mock.Mock(
return_value=self.new_address_scope
)
@ -90,7 +90,7 @@ class TestCreateAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_address_scope.assert_called_once_with(
self.network_client.create_address_scope.assert_called_once_with(
**{
'ip_version': self.new_address_scope.ip_version,
'name': self.new_address_scope.name,
@ -121,7 +121,7 @@ class TestCreateAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_address_scope.assert_called_once_with(
self.network_client.create_address_scope.assert_called_once_with(
**{
'ip_version': self.new_address_scope.ip_version,
'shared': True,
@ -145,7 +145,7 @@ class TestCreateAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_address_scope.assert_called_once_with(
self.network_client.create_address_scope.assert_called_once_with(
**{
'ip_version': self.new_address_scope.ip_version,
'shared': False,
@ -162,9 +162,11 @@ class TestDeleteAddressScope(TestAddressScope):
def setUp(self):
super(TestDeleteAddressScope, self).setUp()
self.network.delete_address_scope = mock.Mock(return_value=None)
self.network.find_address_scope = network_fakes.get_address_scopes(
address_scopes=self._address_scopes
self.network_client.delete_address_scope = mock.Mock(return_value=None)
self.network_client.find_address_scope = (
network_fakes.get_address_scopes(
address_scopes=self._address_scopes
)
)
# Get the command object to test
@ -181,10 +183,10 @@ class TestDeleteAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_address_scope.assert_called_once_with(
self.network_client.find_address_scope.assert_called_once_with(
self._address_scopes[0].name, ignore_missing=False
)
self.network.delete_address_scope.assert_called_once_with(
self.network_client.delete_address_scope.assert_called_once_with(
self._address_scopes[0]
)
self.assertIsNone(result)
@ -205,7 +207,7 @@ class TestDeleteAddressScope(TestAddressScope):
calls = []
for a in self._address_scopes:
calls.append(call(a))
self.network.delete_address_scope.assert_has_calls(calls)
self.network_client.delete_address_scope.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_address_scopes_delete_with_exception(self):
@ -222,7 +224,7 @@ class TestDeleteAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._address_scopes[0], exceptions.CommandError]
self.network.find_address_scope = mock.Mock(
self.network_client.find_address_scope = mock.Mock(
side_effect=find_mock_result
)
@ -232,13 +234,13 @@ class TestDeleteAddressScope(TestAddressScope):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 address scopes failed to delete.', str(e))
self.network.find_address_scope.assert_any_call(
self.network_client.find_address_scope.assert_any_call(
self._address_scopes[0].name, ignore_missing=False
)
self.network.find_address_scope.assert_any_call(
self.network_client.find_address_scope.assert_any_call(
'unexist_address_scope', ignore_missing=False
)
self.network.delete_address_scope.assert_called_once_with(
self.network_client.delete_address_scope.assert_called_once_with(
self._address_scopes[0]
)
@ -267,7 +269,7 @@ class TestListAddressScope(TestAddressScope):
def setUp(self):
super(TestListAddressScope, self).setUp()
self.network.address_scopes = mock.Mock(
self.network_client.address_scopes = mock.Mock(
return_value=self.address_scopes
)
@ -281,7 +283,7 @@ class TestListAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_scopes.assert_called_once_with(**{})
self.network_client.address_scopes.assert_called_once_with(**{})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -296,7 +298,7 @@ class TestListAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_scopes.assert_called_once_with(
self.network_client.address_scopes.assert_called_once_with(
**{'name': self.address_scopes[0].name}
)
self.assertEqual(self.columns, columns)
@ -313,7 +315,7 @@ class TestListAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_scopes.assert_called_once_with(
self.network_client.address_scopes.assert_called_once_with(
**{'ip_version': 4}
)
self.assertEqual(self.columns, columns)
@ -332,7 +334,7 @@ class TestListAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_scopes.assert_called_once_with(
self.network_client.address_scopes.assert_called_once_with(
**{'project_id': project.id}
)
self.assertEqual(self.columns, columns)
@ -355,7 +357,7 @@ class TestListAddressScope(TestAddressScope):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.address_scopes.assert_called_once_with(**filters)
self.network_client.address_scopes.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -369,7 +371,7 @@ class TestListAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_scopes.assert_called_once_with(
self.network_client.address_scopes.assert_called_once_with(
**{'is_shared': True}
)
self.assertEqual(self.columns, columns)
@ -385,7 +387,7 @@ class TestListAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.address_scopes.assert_called_once_with(
self.network_client.address_scopes.assert_called_once_with(
**{'is_shared': False}
)
self.assertEqual(self.columns, columns)
@ -398,8 +400,8 @@ class TestSetAddressScope(TestAddressScope):
def setUp(self):
super(TestSetAddressScope, self).setUp()
self.network.update_address_scope = mock.Mock(return_value=None)
self.network.find_address_scope = mock.Mock(
self.network_client.update_address_scope = mock.Mock(return_value=None)
self.network_client.find_address_scope = mock.Mock(
return_value=self._address_scope
)
@ -418,7 +420,7 @@ class TestSetAddressScope(TestAddressScope):
result = self.cmd.take_action(parsed_args)
attrs = {}
self.network.update_address_scope.assert_called_with(
self.network_client.update_address_scope.assert_called_with(
self._address_scope, **attrs
)
self.assertIsNone(result)
@ -442,7 +444,7 @@ class TestSetAddressScope(TestAddressScope):
'name': "new_address_scope",
'shared': True,
}
self.network.update_address_scope.assert_called_with(
self.network_client.update_address_scope.assert_called_with(
self._address_scope, **attrs
)
self.assertIsNone(result)
@ -462,7 +464,7 @@ class TestSetAddressScope(TestAddressScope):
attrs = {
'shared': False,
}
self.network.update_address_scope.assert_called_with(
self.network_client.update_address_scope.assert_called_with(
self._address_scope, **attrs
)
self.assertIsNone(result)
@ -488,7 +490,7 @@ class TestShowAddressScope(TestAddressScope):
def setUp(self):
super(TestShowAddressScope, self).setUp()
self.network.find_address_scope = mock.Mock(
self.network_client.find_address_scope = mock.Mock(
return_value=self._address_scope
)
@ -519,7 +521,7 @@ class TestShowAddressScope(TestAddressScope):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_address_scope.assert_called_once_with(
self.network_client.find_address_scope.assert_called_once_with(
self._address_scope.name, ignore_missing=False
)
self.assertEqual(self.columns, columns)

166
openstackclient/tests/unit/network/v2/test_floating_ip_network.py

@ -30,7 +30,7 @@ class TestFloatingIPNetwork(network_fakes.TestNetworkV2):
super(TestFloatingIPNetwork, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -88,14 +88,16 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
def setUp(self):
super(TestCreateFloatingIPNetwork, self).setUp()
self.network.create_ip = mock.Mock(return_value=self.floating_ip)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.create_ip = mock.Mock(
return_value=self.floating_ip
)
self.network_client.set_tags = mock.Mock(return_value=None)
self.network.find_network = mock.Mock(
self.network_client.find_network = mock.Mock(
return_value=self.floating_network
)
self.network.find_subnet = mock.Mock(return_value=self.subnet)
self.network.find_port = mock.Mock(return_value=self.port)
self.network_client.find_subnet = mock.Mock(return_value=self.subnet)
self.network_client.find_port = mock.Mock(return_value=self.port)
# Get the command object to test
self.cmd = fip.CreateFloatingIP(self.app, self.namespace)
@ -123,7 +125,7 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_ip.assert_called_once_with(
self.network_client.create_ip.assert_called_once_with(
**{
'floating_network_id': self.floating_ip.floating_network_id,
}
@ -163,7 +165,7 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_ip.assert_called_once_with(
self.network_client.create_ip.assert_called_once_with(
**{
'subnet_id': self.subnet.id,
'port_id': self.floating_ip.port_id,
@ -194,7 +196,7 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_ip.assert_called_once_with(
self.network_client.create_ip.assert_called_once_with(
**{
'floating_network_id': self.floating_ip.floating_network_id,
'project_id': project.id,
@ -224,7 +226,7 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_ip.assert_called_once_with(
self.network_client.create_ip.assert_called_once_with(
**{
'floating_network_id': self.floating_ip.floating_network_id,
'project_id': project.id,
@ -235,7 +237,9 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
def test_create_floating_ip_with_qos(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
arglist = [
'--qos-policy',
qos_policy.id,
@ -249,7 +253,7 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_ip.assert_called_once_with(
self.network_client.create_ip.assert_called_once_with(
**{
'floating_network_id': self.floating_ip.floating_network_id,
'qos_policy_id': qos_policy.id,
@ -276,17 +280,17 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_ip.assert_called_once_with(
self.network_client.create_ip.assert_called_once_with(
**{
'floating_network_id': self.floating_ip.floating_network_id,
}
)
if add_tags:
self.network.set_tags.assert_called_once_with(
self.network_client.set_tags.assert_called_once_with(
self.floating_ip, tests_utils.CompareBySet(['red', 'blue'])
)
else:
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
@ -304,14 +308,14 @@ class TestDeleteFloatingIPNetwork(TestFloatingIPNetwork):
def setUp(self):
super(TestDeleteFloatingIPNetwork, self).setUp()
self.network.find_ip = mock.Mock()
self.network.delete_ip = mock.Mock(return_value=None)
self.network_client.find_ip = mock.Mock()
self.network_client.delete_ip = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = fip.DeleteFloatingIP(self.app, self.namespace)
def test_floating_ip_delete(self):
self.network.find_ip.side_effect = [
self.network_client.find_ip.side_effect = [
self.floating_ips[0],
self.floating_ips[1],
]
@ -325,15 +329,17 @@ class TestDeleteFloatingIPNetwork(TestFloatingIPNetwork):
result = self.cmd.take_action(parsed_args)
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ips[0].id,
ignore_missing=False,
)
self.network.delete_ip.assert_called_once_with(self.floating_ips[0])
self.network_client.delete_ip.assert_called_once_with(
self.floating_ips[0]
)
self.assertIsNone(result)
def test_floating_ip_delete_multi(self):
self.network.find_ip.side_effect = [
self.network_client.find_ip.side_effect = [
self.floating_ips[0],
self.floating_ips[1],
]
@ -359,16 +365,16 @@ class TestDeleteFloatingIPNetwork(TestFloatingIPNetwork):
ignore_missing=False,
),
]
self.network.find_ip.assert_has_calls(calls)
self.network_client.find_ip.assert_has_calls(calls)
calls = []
for f in self.floating_ips:
calls.append(call(f))
self.network.delete_ip.assert_has_calls(calls)
self.network_client.delete_ip.assert_has_calls(calls)
self.assertIsNone(result)
def test_floating_ip_delete_multi_exception(self):
self.network.find_ip.side_effect = [
self.network_client.find_ip.side_effect = [
self.floating_ips[0],
exceptions.CommandError,
]
@ -387,15 +393,17 @@ class TestDeleteFloatingIPNetwork(TestFloatingIPNetwork):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 floating_ips failed to delete.', str(e))
self.network.find_ip.assert_any_call(
self.network_client.find_ip.assert_any_call(
self.floating_ips[0].id,
ignore_missing=False,
)
self.network.find_ip.assert_any_call(
self.network_client.find_ip.assert_any_call(
'unexist_floating_ip',
ignore_missing=False,
)
self.network.delete_ip.assert_called_once_with(self.floating_ips[0])
self.network_client.delete_ip.assert_called_once_with(
self.floating_ips[0]
)
class TestListFloatingIPNetwork(TestFloatingIPNetwork):
@ -467,10 +475,14 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
def setUp(self):
super(TestListFloatingIPNetwork, self).setUp()
self.network.ips = mock.Mock(return_value=self.floating_ips)
self.network.find_network = mock.Mock(return_value=self.fake_network)
self.network.find_port = mock.Mock(return_value=self.fake_port)
self.network.find_router = mock.Mock(return_value=self.fake_router)
self.network_client.ips = mock.Mock(return_value=self.floating_ips)
self.network_client.find_network = mock.Mock(
return_value=self.fake_network
)
self.network_client.find_port = mock.Mock(return_value=self.fake_port)
self.network_client.find_router = mock.Mock(
return_value=self.fake_router
)
# Get the command object to test
self.cmd = fip.ListFloatingIP(self.app, self.namespace)
@ -482,7 +494,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with()
self.network_client.ips.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -498,7 +510,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with(
self.network_client.ips.assert_called_once_with(
**{
'floating_network_id': 'fake_network_id',
}
@ -518,7 +530,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with(
self.network_client.ips.assert_called_once_with(
**{
'port_id': 'fake_port_id',
}
@ -538,7 +550,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with(
self.network_client.ips.assert_called_once_with(
**{
'fixed_ip_address': self.floating_ips[0].fixed_ip_address,
}
@ -558,7 +570,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with(
self.network_client.ips.assert_called_once_with(
**{
'floating_ip_address': self.floating_ips[
0
@ -580,7 +592,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with()
self.network_client.ips.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
@ -597,7 +609,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with(
self.network_client.ips.assert_called_once_with(
**{
'status': 'ACTIVE',
}
@ -620,7 +632,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.ips.assert_called_once_with(**filters)
self.network_client.ips.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -642,7 +654,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.ips.assert_called_once_with(**filters)
self.network_client.ips.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -659,7 +671,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with(
self.network_client.ips.assert_called_once_with(
**{
'router_id': 'fake_router_id',
}
@ -687,7 +699,7 @@ class TestListFloatingIPNetwork(TestFloatingIPNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ips.assert_called_once_with(
self.network_client.ips.assert_called_once_with(
**{
'tags': 'red,blue',
'any_tags': 'red,green',
@ -738,7 +750,7 @@ class TestShowFloatingIPNetwork(TestFloatingIPNetwork):
def setUp(self):
super(TestShowFloatingIPNetwork, self).setUp()
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
# Get the command object to test
self.cmd = fip.ShowFloatingIP(self.app, self.namespace)
@ -754,7 +766,7 @@ class TestShowFloatingIPNetwork(TestFloatingIPNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
@ -779,10 +791,10 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
def setUp(self):
super(TestSetFloatingIP, self).setUp()
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network.find_port = mock.Mock(return_value=self.port)
self.network.update_ip = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.find_port = mock.Mock(return_value=self.port)
self.network_client.update_ip = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = fip.SetFloatingIP(self.app, self.namespace)
@ -805,12 +817,12 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
'port_id': self.floating_ip.port_id,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
@ -835,11 +847,11 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
'port_id': self.floating_ip.port_id,
'fixed_ip_address': self.floating_ip.fixed_ip_address,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
@ -864,17 +876,19 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
'port_id': self.floating_ip.port_id,
'description': self.floating_ip.description,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
def test_qos_policy_option(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
arglist = [
"--qos-policy",
qos_policy.id,
@ -891,17 +905,19 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
attrs = {
'qos_policy_id': qos_policy.id,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
def test_port_and_qos_policy_option(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
arglist = [
"--qos-policy",
qos_policy.id,
@ -922,11 +938,11 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
'qos_policy_id': qos_policy.id,
'port_id': self.floating_ip.port_id,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
@ -946,11 +962,11 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
attrs = {
'qos_policy_id': None,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
@ -974,11 +990,11 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
'qos_policy_id': None,
'port_id': self.floating_ip.port_id,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
@ -997,8 +1013,8 @@ class TestSetFloatingIP(TestFloatingIPNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_ip.called)
self.network.set_tags.assert_called_once_with(
self.assertFalse(self.network_client.update_ip.called)
self.network_client.set_tags.assert_called_once_with(
self.floating_ip, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)
@ -1026,9 +1042,9 @@ class TestUnsetFloatingIP(TestFloatingIPNetwork):
def setUp(self):
super(TestUnsetFloatingIP, self).setUp()
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network.update_ip = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.update_ip = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = fip.UnsetFloatingIP(self.app, self.namespace)
@ -1049,11 +1065,11 @@ class TestUnsetFloatingIP(TestFloatingIPNetwork):
attrs = {
'port_id': None,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
@ -1075,11 +1091,11 @@ class TestUnsetFloatingIP(TestFloatingIPNetwork):
attrs = {
'qos_policy_id': None,
}
self.network.find_ip.assert_called_once_with(
self.network_client.find_ip.assert_called_once_with(
self.floating_ip.id,
ignore_missing=False,
)
self.network.update_ip.assert_called_once_with(
self.network_client.update_ip.assert_called_once_with(
self.floating_ip, **attrs
)
@ -1100,8 +1116,8 @@ class TestUnsetFloatingIP(TestFloatingIPNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_ip.called)
self.network.set_tags.assert_called_once_with(
self.assertFalse(self.network_client.update_ip.called)
self.network_client.set_tags.assert_called_once_with(
self.floating_ip, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)

2
openstackclient/tests/unit/network/v2/test_floating_ip_pool_network.py

@ -25,7 +25,7 @@ class TestFloatingIPPoolNetwork(network_fakes.TestNetworkV2):
super(TestFloatingIPPoolNetwork, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
class TestListFloatingIPPoolNetwork(TestFloatingIPPoolNetwork):

60
openstackclient/tests/unit/network/v2/test_floating_ip_port_forwarding.py

@ -27,13 +27,13 @@ from openstackclient.tests.unit import utils as tests_utils
class TestFloatingIPPortForwarding(network_fakes.TestNetworkV2):
def setUp(self):
super(TestFloatingIPPortForwarding, self).setUp()
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.floating_ip = (
network_fakes.FakeFloatingIP.create_one_floating_ip()
)
self.port = network_fakes.create_one_port()
self.project = identity_fakes_v2.FakeProject.create_one_project()
self.network.find_port = mock.Mock(return_value=self.port)
self.network_client.find_port = mock.Mock(return_value=self.port)
class TestCreateFloatingIPPortForwarding(TestFloatingIPPortForwarding):
@ -54,11 +54,11 @@ class TestCreateFloatingIPPortForwarding(TestFloatingIPPortForwarding):
},
)
self.network.create_floating_ip_port_forwarding = mock.Mock(
self.network_client.create_floating_ip_port_forwarding = mock.Mock(
return_value=self.new_port_forwarding
)
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
# Get the command object to test
self.cmd = floating_ip_port_forwarding.CreateFloatingIPPortForwarding(
@ -144,7 +144,7 @@ class TestCreateFloatingIPPortForwarding(TestFloatingIPPortForwarding):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_floating_ip_port_forwarding.assert_called_once_with( # noqa: E501
self.network_client.create_floating_ip_port_forwarding.assert_called_once_with( # noqa: E501
self.new_port_forwarding.floatingip_id,
**{
'external_port_range': self.new_port_forwarding_with_ranges.external_port_range, # noqa: E501
@ -197,7 +197,7 @@ class TestCreateFloatingIPPortForwarding(TestFloatingIPPortForwarding):
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual(msg, str(e))
self.network.create_floating_ip_port_forwarding.assert_not_called()
self.network_client.create_floating_ip_port_forwarding.assert_not_called()
def test_create_all_options_with_invalid_range_exception(self):
invalid_port_range = '80:70'
@ -241,7 +241,7 @@ class TestCreateFloatingIPPortForwarding(TestFloatingIPPortForwarding):
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual(msg, str(e))
self.network.create_floating_ip_port_forwarding.assert_not_called()
self.network_client.create_floating_ip_port_forwarding.assert_not_called()
def test_create_all_options_with_unmatch_ranges_exception(self):
internal_range = '80:90'
@ -286,7 +286,7 @@ class TestCreateFloatingIPPortForwarding(TestFloatingIPPortForwarding):
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual(msg, str(e))
self.network.create_floating_ip_port_forwarding.assert_not_called()
self.network_client.create_floating_ip_port_forwarding.assert_not_called()
def test_create_all_options(self):
arglist = [
@ -325,7 +325,7 @@ class TestCreateFloatingIPPortForwarding(TestFloatingIPPortForwarding):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_floating_ip_port_forwarding.assert_called_once_with( # noqa: E501
self.network_client.create_floating_ip_port_forwarding.assert_called_once_with( # noqa: E501
self.new_port_forwarding.floatingip_id,
**{
'external_port': self.new_port_forwarding.external_port,
@ -351,11 +351,11 @@ class TestDeleteFloatingIPPortForwarding(TestFloatingIPPortForwarding):
},
)
)
self.network.delete_floating_ip_port_forwarding = mock.Mock(
self.network_client.delete_floating_ip_port_forwarding = mock.Mock(
return_value=None
)
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
# Get the command object to test
self.cmd = floating_ip_port_forwarding.DeleteFloatingIPPortForwarding(
self.app, self.namespace
@ -375,7 +375,7 @@ class TestDeleteFloatingIPPortForwarding(TestFloatingIPPortForwarding):
result = self.cmd.take_action(parsed_args)
self.network.delete_floating_ip_port_forwarding.assert_called_once_with( # noqa: E501
self.network_client.delete_floating_ip_port_forwarding.assert_called_once_with( # noqa: E501
self.floating_ip.id,
self._port_forwarding[0].id,
ignore_missing=False,
@ -405,7 +405,9 @@ class TestDeleteFloatingIPPortForwarding(TestFloatingIPPortForwarding):
for a in self._port_forwarding:
calls.append(call(a.floatingip_id, a.id, ignore_missing=False))
self.network.delete_floating_ip_port_forwarding.assert_has_calls(calls)
self.network_client.delete_floating_ip_port_forwarding.assert_has_calls(
calls
)
self.assertIsNone(result)
def test_multi_port_forwarding_delete_with_exception(self):
@ -425,8 +427,8 @@ class TestDeleteFloatingIPPortForwarding(TestFloatingIPPortForwarding):
delete_mock_result = [None, exceptions.CommandError]
self.network.delete_floating_ip_port_forwarding = mock.MagicMock(
side_effect=delete_mock_result
self.network_client.delete_floating_ip_port_forwarding = (
mock.MagicMock(side_effect=delete_mock_result)
)
try:
@ -437,12 +439,12 @@ class TestDeleteFloatingIPPortForwarding(TestFloatingIPPortForwarding):
'1 of 2 Port forwarding failed to delete.', str(e)
)
self.network.delete_floating_ip_port_forwarding.assert_any_call(
self.network_client.delete_floating_ip_port_forwarding.assert_any_call(
self.floating_ip.id,
'unexist_port_forwarding_id',
ignore_missing=False,
)
self.network.delete_floating_ip_port_forwarding.assert_any_call(
self.network_client.delete_floating_ip_port_forwarding.assert_any_call(
self.floating_ip.id,
self._port_forwarding[0].id,
ignore_missing=False,
@ -488,10 +490,10 @@ class TestListFloatingIPPortForwarding(TestFloatingIPPortForwarding):
port_forwarding.description,
)
)
self.network.floating_ip_port_forwardings = mock.Mock(
self.network_client.floating_ip_port_forwardings = mock.Mock(
return_value=self.port_forwardings
)
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
# Get the command object to test
self.cmd = floating_ip_port_forwarding.ListFloatingIPPortForwarding(
self.app, self.namespace
@ -504,7 +506,7 @@ class TestListFloatingIPPortForwarding(TestFloatingIPPortForwarding):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.floating_ip_port_forwardings.assert_called_once_with(
self.network_client.floating_ip_port_forwardings.assert_called_once_with(
self.floating_ip, **{}
)
self.assertEqual(self.columns, columns)
@ -539,7 +541,7 @@ class TestListFloatingIPPortForwarding(TestFloatingIPPortForwarding):
'protocol': self.port_forwardings[0].protocol,
}
self.network.floating_ip_port_forwardings.assert_called_once_with(
self.network_client.floating_ip_port_forwardings.assert_called_once_with(
self.floating_ip, **query
)
self.assertEqual(self.columns, columns)
@ -555,14 +557,14 @@ class TestSetFloatingIPPortForwarding(TestFloatingIPPortForwarding):
'floatingip_id': self.floating_ip.id,
}
)
self.network.update_floating_ip_port_forwarding = mock.Mock(
self.network_client.update_floating_ip_port_forwarding = mock.Mock(
return_value=None
)
self.network.find_floating_ip_port_forwarding = mock.Mock(
self.network_client.find_floating_ip_port_forwarding = mock.Mock(
return_value=self._port_forwarding
)
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
# Get the command object to test
self.cmd = floating_ip_port_forwarding.SetFloatingIPPortForwarding(
self.app, self.namespace
@ -582,7 +584,7 @@ class TestSetFloatingIPPortForwarding(TestFloatingIPPortForwarding):
result = self.cmd.take_action(parsed_args)
attrs = {}
self.network.update_floating_ip_port_forwarding.assert_called_with(
self.network_client.update_floating_ip_port_forwarding.assert_called_with(
self._port_forwarding.floatingip_id,
self._port_forwarding.id,
**attrs
@ -643,7 +645,7 @@ class TestSetFloatingIPPortForwarding(TestFloatingIPPortForwarding):
result = self.cmd.take_action(parsed_args)
self.network.update_floating_ip_port_forwarding.assert_called_with(
self.network_client.update_floating_ip_port_forwarding.assert_called_with(
self._port_forwarding.floatingip_id,
self._port_forwarding.id,
**attrs
@ -688,10 +690,10 @@ class TestShowFloatingIPPortForwarding(TestFloatingIPPortForwarding):
self._port_forwarding.internal_port_range,
self._port_forwarding.protocol,
)
self.network.find_floating_ip_port_forwarding = mock.Mock(
self.network_client.find_floating_ip_port_forwarding = mock.Mock(
return_value=self._port_forwarding
)
self.network.find_ip = mock.Mock(return_value=self.floating_ip)
self.network_client.find_ip = mock.Mock(return_value=self.floating_ip)
# Get the command object to test
self.cmd = floating_ip_port_forwarding.ShowFloatingIPPortForwarding(
self.app, self.namespace
@ -723,7 +725,7 @@ class TestShowFloatingIPPortForwarding(TestFloatingIPPortForwarding):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_floating_ip_port_forwarding.assert_called_once_with(
self.network_client.find_floating_ip_port_forwarding.assert_called_once_with(
self.floating_ip, self._port_forwarding.id, ignore_missing=False
)

20
openstackclient/tests/unit/network/v2/test_ip_availability.py

@ -26,7 +26,7 @@ class TestIPAvailability(network_fakes.TestNetworkV2):
super(TestIPAvailability, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
@ -58,7 +58,7 @@ class TestListIPAvailability(TestIPAvailability):
super(TestListIPAvailability, self).setUp()
self.cmd = ip_availability.ListIPAvailability(self.app, self.namespace)
self.network.network_ip_availabilities = mock.Mock(
self.network_client.network_ip_availabilities = mock.Mock(
return_value=self._ip_availability
)
@ -71,7 +71,7 @@ class TestListIPAvailability(TestIPAvailability):
columns, data = self.cmd.take_action(parsed_args)
filters = {'ip_version': 4}
self.network.network_ip_availabilities.assert_called_once_with(
self.network_client.network_ip_availabilities.assert_called_once_with(
**filters
)
self.assertEqual(self.columns, columns)
@ -89,7 +89,7 @@ class TestListIPAvailability(TestIPAvailability):
columns, data = self.cmd.take_action(parsed_args)
filters = {'ip_version': 4}
self.network.network_ip_availabilities.assert_called_once_with(
self.network_client.network_ip_availabilities.assert_called_once_with(
**filters
)
self.assertEqual(self.columns, columns)
@ -104,7 +104,7 @@ class TestListIPAvailability(TestIPAvailability):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': self.project.id, 'ip_version': 4}
self.network.network_ip_availabilities.assert_called_once_with(
self.network_client.network_ip_availabilities.assert_called_once_with(
**filters
)
self.assertEqual(self.columns, columns)
@ -137,10 +137,12 @@ class TestShowIPAvailability(TestIPAvailability):
def setUp(self):
super(TestShowIPAvailability, self).setUp()
self.network.find_network_ip_availability = mock.Mock(
self.network_client.find_network_ip_availability = mock.Mock(
return_value=self._ip_availability
)
self.network.find_network = mock.Mock(return_value=self._network)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
# Get the command object to test
self.cmd = ip_availability.ShowIPAvailability(self.app, self.namespace)
@ -164,10 +166,10 @@ class TestShowIPAvailability(TestIPAvailability):
verifylist = [('network', self._ip_availability.network_name)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_network_ip_availability.assert_called_once_with(
self.network_client.find_network_ip_availability.assert_called_once_with(
self._ip_availability.network_id, ignore_missing=False
)
self.network.find_network.assert_called_once_with(
self.network_client.find_network.assert_called_once_with(
self._ip_availability.network_name, ignore_missing=False
)
self.assertEqual(self.columns, columns)

36
openstackclient/tests/unit/network/v2/test_l3_conntrack_helper.py

@ -24,9 +24,9 @@ class TestConntrackHelper(network_fakes.TestNetworkV2):
def setUp(self):
super(TestConntrackHelper, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.router = network_fakes.FakeRouter.create_one_router()
self.network.find_router = mock.Mock(return_value=self.router)
self.network_client.find_router = mock.Mock(return_value=self.router)
class TestCreateL3ConntrackHelper(TestConntrackHelper):
@ -47,7 +47,7 @@ class TestCreateL3ConntrackHelper(TestConntrackHelper):
self.ct_helper.protocol,
self.ct_helper.router_id,
)
self.network.create_conntrack_helper = mock.Mock(
self.network_client.create_conntrack_helper = mock.Mock(
return_value=self.ct_helper
)
@ -89,7 +89,7 @@ class TestCreateL3ConntrackHelper(TestConntrackHelper):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_conntrack_helper.assert_called_once_with(
self.network_client.create_conntrack_helper.assert_called_once_with(
self.router.id, **{'helper': 'tftp', 'protocol': 'udp', 'port': 69}
)
self.assertEqual(self.columns, columns)
@ -122,7 +122,9 @@ class TestDeleteL3ConntrackHelper(TestConntrackHelper):
attrs
)
)
self.network.delete_conntrack_helper = mock.Mock(return_value=None)
self.network_client.delete_conntrack_helper = mock.Mock(
return_value=None
)
# Get the command object to test
self.cmd = l3_conntrack_helper.DeleteConntrackHelper(
@ -137,7 +139,7 @@ class TestDeleteL3ConntrackHelper(TestConntrackHelper):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_conntrack_helper.assert_called_once_with(
self.network_client.delete_conntrack_helper.assert_called_once_with(
self.ct_helper.id, self.router.id, ignore_missing=False
)
self.assertIsNone(result)
@ -148,7 +150,7 @@ class TestDeleteL3ConntrackHelper(TestConntrackHelper):
('conntrack_helper_id', [self.ct_helper.id]),
('router', self.router.id),
]
self.network.delete_conntrack_helper.side_effect = Exception(
self.network_client.delete_conntrack_helper.side_effect = Exception(
'Error message'
)
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@ -184,7 +186,9 @@ class TestListL3ConntrackHelper(TestConntrackHelper):
ct_helper.port,
)
)
self.network.conntrack_helpers = mock.Mock(return_value=ct_helpers)
self.network_client.conntrack_helpers = mock.Mock(
return_value=ct_helpers
)
# Get the command object to test
self.cmd = l3_conntrack_helper.ListConntrackHelper(
@ -200,7 +204,9 @@ class TestListL3ConntrackHelper(TestConntrackHelper):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.conntrack_helpers.assert_called_once_with(self.router.id)
self.network_client.conntrack_helpers.assert_called_once_with(
self.router.id
)
self.assertEqual(self.columns, columns)
list_data = list(data)
self.assertEqual(len(self.data), len(list_data))
@ -217,7 +223,9 @@ class TestSetL3ConntrackHelper(TestConntrackHelper):
attrs
)
)
self.network.update_conntrack_helper = mock.Mock(return_value=None)
self.network_client.update_conntrack_helper = mock.Mock(
return_value=None
)
# Get the command object to test
self.cmd = l3_conntrack_helper.SetConntrackHelper(
@ -237,7 +245,7 @@ class TestSetL3ConntrackHelper(TestConntrackHelper):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_conntrack_helper.assert_called_once_with(
self.network_client.update_conntrack_helper.assert_called_once_with(
self.ct_helper.id, self.router.id
)
self.assertIsNone(result)
@ -258,7 +266,7 @@ class TestSetL3ConntrackHelper(TestConntrackHelper):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_conntrack_helper.assert_called_once_with(
self.network_client.update_conntrack_helper.assert_called_once_with(
self.ct_helper.id, self.router.id, port=124
)
self.assertIsNone(result)
@ -282,7 +290,7 @@ class TestShowL3ConntrackHelper(TestConntrackHelper):
self.ct_helper.protocol,
self.ct_helper.router_id,
)
self.network.get_conntrack_helper = mock.Mock(
self.network_client.get_conntrack_helper = mock.Mock(
return_value=self.ct_helper
)
@ -317,7 +325,7 @@ class TestShowL3ConntrackHelper(TestConntrackHelper):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_conntrack_helper.assert_called_once_with(
self.network_client.get_conntrack_helper.assert_called_once_with(
self.ct_helper.id, self.router.id
)
self.assertEqual(self.columns, columns)

68
openstackclient/tests/unit/network/v2/test_local_ip.py

@ -29,7 +29,7 @@ class TestLocalIP(network_fakes.TestNetworkV2):
super().setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -79,13 +79,13 @@ class TestCreateLocalIP(TestLocalIP):
def setUp(self):
super().setUp()
self.network.create_local_ip = mock.Mock(
self.network_client.create_local_ip = mock.Mock(
return_value=self.new_local_ip
)
self.network.find_network = mock.Mock(
self.network_client.find_network = mock.Mock(
return_value=self.local_ip_network
)
self.network.find_port = mock.Mock(return_value=self.port)
self.network_client.find_port = mock.Mock(return_value=self.port)
# Get the command object to test
self.cmd = local_ip.CreateLocalIP(self.app, self.namespace)
@ -97,7 +97,7 @@ class TestCreateLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, [], [])
columns, data = self.cmd.take_action(parsed_args)
self.network.create_local_ip.assert_called_once_with(**{})
self.network_client.create_local_ip.assert_called_once_with(**{})
self.assertEqual(set(self.columns), set(columns))
self.assertCountEqual(self.data, data)
@ -131,7 +131,7 @@ class TestCreateLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_local_ip.assert_called_once_with(
self.network_client.create_local_ip.assert_called_once_with(
**{
'name': self.new_local_ip.name,
'description': self.new_local_ip.description,
@ -151,8 +151,8 @@ class TestDeleteLocalIP(TestLocalIP):
def setUp(self):
super().setUp()
self.network.delete_local_ip = mock.Mock(return_value=None)
self.network.find_local_ip = network_fakes.get_local_ips(
self.network_client.delete_local_ip = mock.Mock(return_value=None)
self.network_client.find_local_ip = network_fakes.get_local_ips(
local_ips=self._local_ips
)
@ -170,10 +170,10 @@ class TestDeleteLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_local_ip.assert_called_once_with(
self.network_client.find_local_ip.assert_called_once_with(
self._local_ips[0].name, ignore_missing=False
)
self.network.delete_local_ip.assert_called_once_with(
self.network_client.delete_local_ip.assert_called_once_with(
self._local_ips[0]
)
self.assertIsNone(result)
@ -193,7 +193,7 @@ class TestDeleteLocalIP(TestLocalIP):
calls = []
for a in self._local_ips:
calls.append(call(a))
self.network.delete_local_ip.assert_has_calls(calls)
self.network_client.delete_local_ip.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_local_ips_delete_with_exception(self):
@ -207,7 +207,9 @@ class TestDeleteLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._local_ips[0], exceptions.CommandError]
self.network.find_local_ip = mock.Mock(side_effect=find_mock_result)
self.network_client.find_local_ip = mock.Mock(
side_effect=find_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -215,13 +217,13 @@ class TestDeleteLocalIP(TestLocalIP):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 local IPs failed to delete.', str(e))
self.network.find_local_ip.assert_any_call(
self.network_client.find_local_ip.assert_any_call(
self._local_ips[0].name, ignore_missing=False
)
self.network.find_local_ip.assert_any_call(
self.network_client.find_local_ip.assert_any_call(
'unexist_local_ip', ignore_missing=False
)
self.network.delete_local_ip.assert_called_once_with(
self.network_client.delete_local_ip.assert_called_once_with(
self._local_ips[0]
)
@ -258,8 +260,10 @@ class TestListLocalIP(TestLocalIP):
def setUp(self):
super().setUp()
self.network.local_ips = mock.Mock(return_value=self.local_ips)
self.network.find_network = mock.Mock(return_value=self.fake_network)
self.network_client.local_ips = mock.Mock(return_value=self.local_ips)
self.network_client.find_network = mock.Mock(
return_value=self.fake_network
)
# Get the command object to test
self.cmd = local_ip.ListLocalIP(self.app, self.namespace)
@ -271,7 +275,7 @@ class TestListLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.local_ips.assert_called_once_with(**{})
self.network_client.local_ips.assert_called_once_with(**{})
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -286,7 +290,7 @@ class TestListLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.local_ips.assert_called_once_with(
self.network_client.local_ips.assert_called_once_with(
**{'name': self.local_ips[0].name}
)
self.assertEqual(self.columns, columns)
@ -305,7 +309,7 @@ class TestListLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.local_ips.assert_called_once_with(
self.network_client.local_ips.assert_called_once_with(
**{'project_id': project.id}
)
self.assertEqual(self.columns, columns)
@ -328,7 +332,7 @@ class TestListLocalIP(TestLocalIP):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.local_ips.assert_called_once_with(**filters)
self.network_client.local_ips.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -344,7 +348,7 @@ class TestListLocalIP(TestLocalIP):
columns, data = self.cmd.take_action(parsed_args)
self.network.local_ips.assert_called_once_with(
self.network_client.local_ips.assert_called_once_with(
**{
'network_id': 'fake_network_id',
}
@ -365,7 +369,7 @@ class TestListLocalIP(TestLocalIP):
columns, data = self.cmd.take_action(parsed_args)
self.network.local_ips.assert_called_once_with(
self.network_client.local_ips.assert_called_once_with(
**{
'local_ip_address': self.local_ips[0].local_ip_address,
}
@ -385,7 +389,7 @@ class TestListLocalIP(TestLocalIP):
columns, data = self.cmd.take_action(parsed_args)
self.network.local_ips.assert_called_once_with(
self.network_client.local_ips.assert_called_once_with(
**{
'ip_mode': self.local_ips[0].ip_mode,
}
@ -400,8 +404,10 @@ class TestSetLocalIP(TestLocalIP):
def setUp(self):
super().setUp()
self.network.update_local_ip = mock.Mock(return_value=None)
self.network.find_local_ip = mock.Mock(return_value=self._local_ip)
self.network_client.update_local_ip = mock.Mock(return_value=None)
self.network_client.find_local_ip = mock.Mock(
return_value=self._local_ip
)
# Get the command object to test
self.cmd = local_ip.SetLocalIP(self.app, self.namespace)
@ -417,7 +423,7 @@ class TestSetLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_local_ip.assert_not_called()
self.network_client.update_local_ip.assert_not_called()
self.assertIsNone(result)
def test_set_name_and_description(self):
@ -440,7 +446,7 @@ class TestSetLocalIP(TestLocalIP):
'name': "new_local_ip_name",
'description': 'new_local_ip_description',
}
self.network.update_local_ip.assert_called_with(
self.network_client.update_local_ip.assert_called_with(
self._local_ip, **attrs
)
self.assertIsNone(result)
@ -478,7 +484,9 @@ class TestShowLocalIP(TestLocalIP):
def setUp(self):
super().setUp()
self.network.find_local_ip = mock.Mock(return_value=self._local_ip)
self.network_client.find_local_ip = mock.Mock(
return_value=self._local_ip
)
# Get the command object to test
self.cmd = local_ip.ShowLocalIP(self.app, self.namespace)
@ -507,7 +515,7 @@ class TestShowLocalIP(TestLocalIP):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_local_ip.assert_called_once_with(
self.network_client.find_local_ip.assert_called_once_with(
self._local_ip.name, ignore_missing=False
)
self.assertEqual(set(self.columns), set(columns))

44
openstackclient/tests/unit/network/v2/test_local_ip_association.py

@ -26,11 +26,11 @@ from openstackclient.tests.unit.network.v2 import fakes as network_fakes
class TestLocalIPAssociation(network_fakes.TestNetworkV2):
def setUp(self):
super().setUp()
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.local_ip = network_fakes.create_one_local_ip()
self.fixed_port = network_fakes.create_one_port()
self.project = identity_fakes_v2.FakeProject.create_one_project()
self.network.find_port = mock.Mock(return_value=self.fixed_port)
self.network_client.find_port = mock.Mock(return_value=self.fixed_port)
class TestCreateLocalIPAssociation(TestLocalIPAssociation):
@ -44,11 +44,13 @@ class TestCreateLocalIPAssociation(TestLocalIPAssociation):
}
)
)
self.network.create_local_ip_association = mock.Mock(
self.network_client.create_local_ip_association = mock.Mock(
return_value=self.new_local_ip_association
)
self.network.find_local_ip = mock.Mock(return_value=self.local_ip)
self.network_client.find_local_ip = mock.Mock(
return_value=self.local_ip
)
# Get the command object to test
self.cmd = local_ip_association.CreateLocalIPAssociation(
@ -81,7 +83,7 @@ class TestCreateLocalIPAssociation(TestLocalIPAssociation):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_local_ip_association.assert_called_once_with(
self.network_client.create_local_ip_association.assert_called_once_with(
self.new_local_ip_association.local_ip_id,
**{
'fixed_port_id': self.new_local_ip_association.fixed_port_id,
@ -105,7 +107,7 @@ class TestCreateLocalIPAssociation(TestLocalIPAssociation):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_local_ip_association.assert_called_once_with(
self.network_client.create_local_ip_association.assert_called_once_with(
self.new_local_ip_association.local_ip_id,
**{
'fixed_port_id': self.new_local_ip_association.fixed_port_id,
@ -127,9 +129,13 @@ class TestDeleteLocalIPAssociation(TestLocalIPAssociation):
},
)
)
self.network.delete_local_ip_association = mock.Mock(return_value=None)
self.network_client.delete_local_ip_association = mock.Mock(
return_value=None
)
self.network.find_local_ip = mock.Mock(return_value=self.local_ip)
self.network_client.find_local_ip = mock.Mock(
return_value=self.local_ip
)
# Get the command object to test
self.cmd = local_ip_association.DeleteLocalIPAssociation(
self.app, self.namespace
@ -149,7 +155,7 @@ class TestDeleteLocalIPAssociation(TestLocalIPAssociation):
result = self.cmd.take_action(parsed_args)
self.network.delete_local_ip_association.assert_called_once_with(
self.network_client.delete_local_ip_association.assert_called_once_with(
self.local_ip.id,
self._local_ip_association[0].fixed_port_id,
ignore_missing=False,
@ -181,7 +187,7 @@ class TestDeleteLocalIPAssociation(TestLocalIPAssociation):
call(a.local_ip_id, a.fixed_port_id, ignore_missing=False)
)
self.network.delete_local_ip_association.assert_has_calls(calls)
self.network_client.delete_local_ip_association.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_local_ip_association_delete_with_exception(self):
@ -204,7 +210,7 @@ class TestDeleteLocalIPAssociation(TestLocalIPAssociation):
delete_mock_result = [None, exceptions.CommandError]
self.network.delete_local_ip_association = mock.MagicMock(
self.network_client.delete_local_ip_association = mock.MagicMock(
side_effect=delete_mock_result
)
@ -216,10 +222,10 @@ class TestDeleteLocalIPAssociation(TestLocalIPAssociation):
'1 of 2 Local IP Associations failed to delete.', str(e)
)
self.network.delete_local_ip_association.assert_any_call(
self.network_client.delete_local_ip_association.assert_any_call(
self.local_ip.id, 'unexist_fixed_port_id', ignore_missing=False
)
self.network.delete_local_ip_association.assert_any_call(
self.network_client.delete_local_ip_association.assert_any_call(
self.local_ip.id,
self._local_ip_association[0].fixed_port_id,
ignore_missing=False,
@ -257,11 +263,13 @@ class TestListLocalIPAssociation(TestLocalIPAssociation):
lip_assoc.host,
)
)
self.network.local_ip_associations = mock.Mock(
self.network_client.local_ip_associations = mock.Mock(
return_value=self.local_ip_associations
)
self.network.find_local_ip = mock.Mock(return_value=self.local_ip)
self.network.find_port = mock.Mock(return_value=self.fixed_port)
self.network_client.find_local_ip = mock.Mock(
return_value=self.local_ip
)
self.network_client.find_port = mock.Mock(return_value=self.fixed_port)
# Get the command object to test
self.cmd = local_ip_association.ListLocalIPAssociation(
self.app, self.namespace
@ -274,7 +282,7 @@ class TestListLocalIPAssociation(TestLocalIPAssociation):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.local_ip_associations.assert_called_once_with(
self.network_client.local_ip_associations.assert_called_once_with(
self.local_ip, **{}
)
self.assertEqual(set(self.columns), set(columns))
@ -307,7 +315,7 @@ class TestListLocalIPAssociation(TestLocalIPAssociation):
'host': self.local_ip_associations[0].host,
}
self.network.local_ip_associations.assert_called_once_with(
self.network_client.local_ip_associations.assert_called_once_with(
self.local_ip, **attrs
)
self.assertEqual(set(self.columns), set(columns))

68
openstackclient/tests/unit/network/v2/test_ndp_proxy.py

@ -30,13 +30,13 @@ class TestNDPProxy(network_fakes.TestNetworkV2):
# Get a shortcut to the DomainManager Mock
self.domains_mock = self.app.client_manager.identity.domains
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.router = network_fakes.FakeRouter.create_one_router(
{'id': 'fake-router-id'}
)
self.network.find_router = mock.Mock(return_value=self.router)
self.network_client.find_router = mock.Mock(return_value=self.router)
self.port = network_fakes.create_one_port()
self.network.find_port = mock.Mock(return_value=self.port)
self.network_client.find_port = mock.Mock(return_value=self.port)
class TestCreateNDPProxy(TestNDPProxy):
@ -69,7 +69,9 @@ class TestCreateNDPProxy(TestNDPProxy):
self.ndp_proxy.router_id,
self.ndp_proxy.updated_at,
)
self.network.create_ndp_proxy = mock.Mock(return_value=self.ndp_proxy)
self.network_client.create_ndp_proxy = mock.Mock(
return_value=self.ndp_proxy
)
# Get the command object to test
self.cmd = ndp_proxy.CreateNDPProxy(self.app, self.namespace)
@ -109,7 +111,7 @@ class TestCreateNDPProxy(TestNDPProxy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_ndp_proxy.assert_called_once_with(
self.network_client.create_ndp_proxy.assert_called_once_with(
**{
'name': self.ndp_proxy.name,
'router_id': self.ndp_proxy.router_id,
@ -128,8 +130,10 @@ class TestDeleteNDPProxy(TestNDPProxy):
attrs = {'router_id': self.router.id, 'port_id': self.port.id}
self.ndp_proxies = network_fakes.create_ndp_proxies(attrs)
self.ndp_proxy = self.ndp_proxies[0]
self.network.delete_ndp_proxy = mock.Mock(return_value=None)
self.network.find_ndp_proxy = mock.Mock(return_value=self.ndp_proxy)
self.network_client.delete_ndp_proxy = mock.Mock(return_value=None)
self.network_client.find_ndp_proxy = mock.Mock(
return_value=self.ndp_proxy
)
# Get the command object to test
self.cmd = ndp_proxy.DeleteNDPProxy(self.app, self.namespace)
@ -139,7 +143,9 @@ class TestDeleteNDPProxy(TestNDPProxy):
verifylist = [('ndp_proxy', [self.ndp_proxy.id])]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_ndp_proxy.assert_called_once_with(self.ndp_proxy)
self.network_client.delete_ndp_proxy.assert_called_once_with(
self.ndp_proxy
)
self.assertIsNone(result)
def test_delete_error(self):
@ -147,7 +153,9 @@ class TestDeleteNDPProxy(TestNDPProxy):
self.ndp_proxy.id,
]
verifylist = [('ndp_proxy', [self.ndp_proxy.id])]
self.network.delete_ndp_proxy.side_effect = Exception('Error message')
self.network_client.delete_ndp_proxy.side_effect = Exception(
'Error message'
)
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(
exceptions.CommandError, self.cmd.take_action, parsed_args
@ -168,7 +176,7 @@ class TestDeleteNDPProxy(TestNDPProxy):
result = self.cmd.take_action(parsed_args)
self.network.delete_ndp_proxy.assert_has_calls(
self.network_client.delete_ndp_proxy.assert_has_calls(
[call(self.ndp_proxy), call(self.ndp_proxy)]
)
self.assertIsNone(result)
@ -198,7 +206,7 @@ class TestListNDPProxy(TestNDPProxy):
)
)
self.network.ndp_proxies = mock.Mock(return_value=ndp_proxies)
self.network_client.ndp_proxies = mock.Mock(return_value=ndp_proxies)
# Get the command object to test
self.cmd = ndp_proxy.ListNDPProxy(self.app, self.namespace)
@ -210,7 +218,7 @@ class TestListNDPProxy(TestNDPProxy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ndp_proxies.assert_called_once_with()
self.network_client.ndp_proxies.assert_called_once_with()
self.assertEqual(self.columns, columns)
list_data = list(data)
self.assertEqual(len(self.data), len(list_data))
@ -229,7 +237,7 @@ class TestListNDPProxy(TestNDPProxy):
columns, data = self.cmd.take_action(parsed_args)
self.network.ndp_proxies.assert_called_once_with(
self.network_client.ndp_proxies.assert_called_once_with(
**{'router_id': 'fake-router-id'}
)
self.assertEqual(self.columns, columns)
@ -247,7 +255,7 @@ class TestListNDPProxy(TestNDPProxy):
columns, data = self.cmd.take_action(parsed_args)
self.network.ndp_proxies.assert_called_once_with(
self.network_client.ndp_proxies.assert_called_once_with(
**{'port_id': self.port.id}
)
self.assertEqual(self.columns, columns)
@ -265,7 +273,7 @@ class TestListNDPProxy(TestNDPProxy):
columns, data = self.cmd.take_action(parsed_args)
self.network.ndp_proxies.assert_called_once_with(
self.network_client.ndp_proxies.assert_called_once_with(
**{'name': 'fake-ndp-proxy-name'}
)
self.assertEqual(self.columns, columns)
@ -283,7 +291,7 @@ class TestListNDPProxy(TestNDPProxy):
columns, data = self.cmd.take_action(parsed_args)
self.network.ndp_proxies.assert_called_once_with(
self.network_client.ndp_proxies.assert_called_once_with(
**{'ip_address': '2001::1:2'}
)
self.assertEqual(self.columns, columns)
@ -302,7 +310,7 @@ class TestListNDPProxy(TestNDPProxy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.ndp_proxies.assert_called_once_with(
self.network_client.ndp_proxies.assert_called_once_with(
**{'project_id': project.id}
)
self.assertEqual(self.columns, columns)
@ -325,7 +333,7 @@ class TestListNDPProxy(TestNDPProxy):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.ndp_proxies.assert_called_once_with(**filters)
self.network_client.ndp_proxies.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertItemsEqual(self.data, list(data))
@ -335,8 +343,10 @@ class TestSetNDPProxy(TestNDPProxy):
super(TestSetNDPProxy, self).setUp()
attrs = {'router_id': self.router.id, 'port_id': self.port.id}
self.ndp_proxy = network_fakes.create_one_ndp_proxy(attrs)
self.network.update_ndp_proxy = mock.Mock(return_value=None)
self.network.find_ndp_proxy = mock.Mock(return_value=self.ndp_proxy)
self.network_client.update_ndp_proxy = mock.Mock(return_value=None)
self.network_client.find_ndp_proxy = mock.Mock(
return_value=self.ndp_proxy
)
# Get the command object to test
self.cmd = ndp_proxy.SetNDPProxy(self.app, self.namespace)
@ -352,7 +362,9 @@ class TestSetNDPProxy(TestNDPProxy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_ndp_proxy.assert_called_once_with(self.ndp_proxy)
self.network_client.update_ndp_proxy.assert_called_once_with(
self.ndp_proxy
)
self.assertIsNone(result)
def test_set_name(self):
@ -369,7 +381,7 @@ class TestSetNDPProxy(TestNDPProxy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_ndp_proxy.assert_called_once_with(
self.network_client.update_ndp_proxy.assert_called_once_with(
self.ndp_proxy, name='fake-name'
)
self.assertIsNone(result)
@ -388,7 +400,7 @@ class TestSetNDPProxy(TestNDPProxy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_ndp_proxy.assert_called_once_with(
self.network_client.update_ndp_proxy.assert_called_once_with(
self.ndp_proxy, description='balala'
)
self.assertIsNone(result)
@ -425,8 +437,12 @@ class TestShowNDPProxy(TestNDPProxy):
self.ndp_proxy.router_id,
self.ndp_proxy.updated_at,
)
self.network.get_ndp_proxy = mock.Mock(return_value=self.ndp_proxy)
self.network.find_ndp_proxy = mock.Mock(return_value=self.ndp_proxy)
self.network_client.get_ndp_proxy = mock.Mock(
return_value=self.ndp_proxy
)
self.network_client.find_ndp_proxy = mock.Mock(
return_value=self.ndp_proxy
)
# Get the command object to test
self.cmd = ndp_proxy.ShowNDPProxy(self.app, self.namespace)
@ -455,7 +471,7 @@ class TestShowNDPProxy(TestNDPProxy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_ndp_proxy.assert_called_once_with(
self.network_client.find_ndp_proxy.assert_called_once_with(
self.ndp_proxy.id, ignore_missing=False
)
self.assertEqual(self.columns, columns)

146
openstackclient/tests/unit/network/v2/test_network.py

@ -33,7 +33,7 @@ class TestNetwork(network_fakes.TestNetworkV2):
super(TestNetwork, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -117,15 +117,19 @@ class TestCreateNetworkIdentityV3(TestNetwork):
def setUp(self):
super(TestCreateNetworkIdentityV3, self).setUp()
self.network.create_network = mock.Mock(return_value=self._network)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.create_network = mock.Mock(
return_value=self._network
)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = network.CreateNetwork(self.app, self.namespace)
self.projects_mock.get.return_value = self.project
self.domains_mock.get.return_value = self.domain
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
def test_create_no_options(self):
arglist = []
@ -154,13 +158,13 @@ class TestCreateNetworkIdentityV3(TestNetwork):
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(
self.network_client.create_network.assert_called_once_with(
**{
'admin_state_up': True,
'name': self._network.name,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(set(self.columns), set(columns))
self.assertCountEqual(self.data, data)
@ -217,7 +221,7 @@ class TestCreateNetworkIdentityV3(TestNetwork):
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(
self.network_client.create_network.assert_called_once_with(
**{
'admin_state_up': False,
'availability_zone_hints': ["nova"],
@ -258,7 +262,7 @@ class TestCreateNetworkIdentityV3(TestNetwork):
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(
self.network_client.create_network.assert_called_once_with(
**{
'admin_state_up': True,
'name': self._network.name,
@ -290,15 +294,15 @@ class TestCreateNetworkIdentityV3(TestNetwork):
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(
self.network_client.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_client.set_tags.assert_called_once_with(
self._network, tests_utils.CompareBySet(['red', 'blue'])
)
else:
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(set(self.columns), set(columns))
self.assertCountEqual(self.data, data)
@ -378,8 +382,10 @@ class TestCreateNetworkIdentityV2(TestNetwork):
def setUp(self):
super(TestCreateNetworkIdentityV2, self).setUp()
self.network.create_network = mock.Mock(return_value=self._network)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.create_network = mock.Mock(
return_value=self._network
)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = network.CreateNetwork(self.app, self.namespace)
@ -415,14 +421,14 @@ class TestCreateNetworkIdentityV2(TestNetwork):
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(
self.network_client.create_network.assert_called_once_with(
**{
'admin_state_up': True,
'name': self._network.name,
'project_id': self.project.id,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(set(self.columns), set(columns))
self.assertCountEqual(self.data, data)
@ -459,9 +465,9 @@ class TestDeleteNetwork(TestNetwork):
# The networks to delete
self._networks = network_fakes.create_networks(count=3)
self.network.delete_network = mock.Mock(return_value=None)
self.network_client.delete_network = mock.Mock(return_value=None)
self.network.find_network = network_fakes.get_networks(
self.network_client.find_network = network_fakes.get_networks(
networks=self._networks
)
@ -479,7 +485,9 @@ class TestDeleteNetwork(TestNetwork):
result = self.cmd.take_action(parsed_args)
self.network.delete_network.assert_called_once_with(self._networks[0])
self.network_client.delete_network.assert_called_once_with(
self._networks[0]
)
self.assertIsNone(result)
def test_delete_multiple_networks(self):
@ -496,7 +504,7 @@ class TestDeleteNetwork(TestNetwork):
calls = []
for n in self._networks:
calls.append(call(n))
self.network.delete_network.assert_has_calls(calls)
self.network_client.delete_network.assert_has_calls(calls)
self.assertIsNone(result)
def test_delete_multiple_networks_exception(self):
@ -516,14 +524,14 @@ class TestDeleteNetwork(TestNetwork):
exceptions.NotFound('404'),
self._networks[1],
]
self.network.find_network = mock.Mock(side_effect=ret_find)
self.network_client.find_network = mock.Mock(side_effect=ret_find)
# Fake exception in delete_network()
ret_delete = [
None,
exceptions.NotFound('404'),
]
self.network.delete_network = mock.Mock(side_effect=ret_delete)
self.network_client.delete_network = mock.Mock(side_effect=ret_delete)
self.assertRaises(
exceptions.CommandError, self.cmd.take_action, parsed_args
@ -535,7 +543,7 @@ class TestDeleteNetwork(TestNetwork):
call(self._networks[0]),
call(self._networks[1]),
]
self.network.delete_network.assert_has_calls(calls)
self.network_client.delete_network.assert_has_calls(calls)
class TestListNetwork(TestNetwork):
@ -595,17 +603,17 @@ class TestListNetwork(TestNetwork):
# Get the command object to test
self.cmd = network.ListNetwork(self.app, self.namespace)
self.network.networks = mock.Mock(return_value=self._network)
self.network_client.networks = mock.Mock(return_value=self._network)
self._agent = network_fakes.create_one_network_agent()
self.network.get_agent = mock.Mock(return_value=self._agent)
self.network_client.get_agent = mock.Mock(return_value=self._agent)
self.network.dhcp_agent_hosting_networks = mock.Mock(
self.network_client.dhcp_agent_hosting_networks = mock.Mock(
return_value=self._network
)
# TestListTagMixin
self._tag_list_resource_mock = self.network.networks
self._tag_list_resource_mock = self.network_client.networks
def test_network_list_no_options(self):
arglist = []
@ -620,7 +628,7 @@ class TestListNetwork(TestNetwork):
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with()
self.network_client.networks.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -639,7 +647,7 @@ class TestListNetwork(TestNetwork):
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'router:external': True, 'is_router_external': True}
)
self.assertEqual(self.columns, columns)
@ -656,7 +664,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'router:external': False, 'is_router_external': False}
)
self.assertEqual(self.columns, columns)
@ -677,7 +685,7 @@ class TestListNetwork(TestNetwork):
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with()
self.network_client.networks.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertCountEqual(self.data_long, list(data))
@ -695,7 +703,9 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(**{'name': test_name})
self.network_client.networks.assert_called_once_with(
**{'name': test_name}
)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -711,7 +721,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'admin_state_up': True, 'is_admin_state_up': True}
)
self.assertEqual(self.columns, columns)
@ -725,7 +735,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'admin_state_up': False, 'is_admin_state_up': False}
)
self.assertEqual(self.columns, columns)
@ -744,7 +754,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'project_id': project.id}
)
@ -768,7 +778,7 @@ class TestListNetwork(TestNetwork):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.networks.assert_called_once_with(**filters)
self.network_client.networks.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -783,7 +793,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'shared': True, 'is_shared': True}
)
self.assertEqual(self.columns, columns)
@ -800,7 +810,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'shared': False, 'is_shared': False}
)
self.assertEqual(self.columns, columns)
@ -820,7 +830,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{'status': test_status}
)
self.assertEqual(self.columns, columns)
@ -838,7 +848,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{
'provider:network_type': network_type,
'provider_network_type': network_type,
@ -859,7 +869,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{
'provider:physical_network': physical_network,
'provider_physical_network': physical_network,
@ -880,7 +890,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{
'provider:segmentation_id': segmentation_id,
'provider_segmentation_id': segmentation_id,
@ -899,7 +909,7 @@ class TestListNetwork(TestNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.dhcp_agent_hosting_networks.assert_called_once_with(
self.network_client.dhcp_agent_hosting_networks.assert_called_once_with(
self._agent
)
@ -926,7 +936,7 @@ class TestListNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.networks.assert_called_once_with(
self.network_client.networks.assert_called_once_with(
**{
'tags': 'red,blue',
'any_tags': 'red,green',
@ -948,11 +958,15 @@ class TestSetNetwork(TestNetwork):
def setUp(self):
super(TestSetNetwork, self).setUp()
self.network.update_network = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.update_network = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
self.network.find_network = mock.Mock(return_value=self._network)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
# Get the command object to test
self.cmd = network.SetNetwork(self.app, self.namespace)
@ -1013,7 +1027,7 @@ class TestSetNetwork(TestNetwork):
'qos_policy_id': self.qos_policy.id,
'dns_domain': 'example.org.',
}
self.network.update_network.assert_called_once_with(
self.network_client.update_network.assert_called_once_with(
self._network, **attrs
)
self.assertIsNone(result)
@ -1046,7 +1060,7 @@ class TestSetNetwork(TestNetwork):
'port_security_enabled': False,
'qos_policy_id': None,
}
self.network.update_network.assert_called_once_with(
self.network_client.update_network.assert_called_once_with(
self._network, **attrs
)
self.assertIsNone(result)
@ -1062,8 +1076,8 @@ class TestSetNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_network.called)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.update_network.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertIsNone(result)
def _test_set_tags(self, with_tags=True):
@ -1081,8 +1095,8 @@ class TestSetNetwork(TestNetwork):
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.assertFalse(self.network_client.update_network.called)
self.network_client.set_tags.assert_called_once_with(
self._network, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)
@ -1160,7 +1174,9 @@ class TestShowNetwork(TestNetwork):
def setUp(self):
super(TestShowNetwork, self).setUp()
self.network.find_network = mock.Mock(return_value=self._network)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
# Get the command object to test
self.cmd = network.ShowNetwork(self.app, self.namespace)
@ -1188,7 +1204,7 @@ class TestShowNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_network.assert_called_once_with(
self.network_client.find_network.assert_called_once_with(
self._network.name, ignore_missing=False
)
@ -1206,11 +1222,15 @@ class TestUnsetNetwork(TestNetwork):
def setUp(self):
super(TestUnsetNetwork, self).setUp()
self.network.update_network = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.update_network = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
self.network.find_network = mock.Mock(return_value=self._network)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
# Get the command object to test
self.cmd = network.UnsetNetwork(self.app, self.namespace)
@ -1226,8 +1246,8 @@ class TestUnsetNetwork(TestNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_network.called)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.update_network.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertIsNone(result)
def _test_unset_tags(self, with_tags=True):
@ -1245,8 +1265,8 @@ class TestUnsetNetwork(TestNetwork):
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.assertFalse(self.network_client.update_network.called)
self.network_client.set_tags.assert_called_once_with(
self._network, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)

116
openstackclient/tests/unit/network/v2/test_network_agent.py

@ -27,7 +27,7 @@ class TestNetworkAgent(network_fakes.TestNetworkV2):
super(TestNetworkAgent, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
class TestAddNetworkToAgent(TestNetworkAgent):
@ -37,10 +37,10 @@ class TestAddNetworkToAgent(TestNetworkAgent):
def setUp(self):
super(TestAddNetworkToAgent, self).setUp()
self.network.get_agent = mock.Mock(return_value=self.agent)
self.network.find_network = mock.Mock(return_value=self.net)
self.network.name = self.network.find_network.name
self.network.add_dhcp_agent_to_network = mock.Mock()
self.network_client.get_agent = mock.Mock(return_value=self.agent)
self.network_client.find_network = mock.Mock(return_value=self.net)
self.network_client.name = self.network_client.find_network.name
self.network_client.add_dhcp_agent_to_network = mock.Mock()
self.cmd = network_agent.AddNetworkToAgent(self.app, self.namespace)
def test_show_no_options(self):
@ -67,7 +67,7 @@ class TestAddNetworkToAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.add_dhcp_agent_to_network.assert_called_once_with(
self.network_client.add_dhcp_agent_to_network.assert_called_once_with(
self.agent, self.net
)
@ -78,10 +78,10 @@ class TestAddRouterAgent(TestNetworkAgent):
def setUp(self):
super(TestAddRouterAgent, self).setUp()
self.network.add_router_to_agent = mock.Mock()
self.network_client.add_router_to_agent = mock.Mock()
self.cmd = network_agent.AddRouterToAgent(self.app, self.namespace)
self.network.get_agent = mock.Mock(return_value=self._agent)
self.network.find_router = mock.Mock(return_value=self._router)
self.network_client.get_agent = mock.Mock(return_value=self._agent)
self.network_client.find_router = mock.Mock(return_value=self._router)
def test_add_no_options(self):
arglist = []
@ -111,7 +111,7 @@ class TestAddRouterAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.add_router_to_agent.assert_called_with(
self.network_client.add_router_to_agent.assert_called_with(
self._agent, self._router
)
self.assertIsNone(result)
@ -122,7 +122,7 @@ class TestDeleteNetworkAgent(TestNetworkAgent):
def setUp(self):
super(TestDeleteNetworkAgent, self).setUp()
self.network.delete_agent = mock.Mock(return_value=None)
self.network_client.delete_agent = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = network_agent.DeleteNetworkAgent(self.app, self.namespace)
@ -138,7 +138,7 @@ class TestDeleteNetworkAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_agent.assert_called_once_with(
self.network_client.delete_agent.assert_called_once_with(
self.network_agents[0].id, ignore_missing=False
)
self.assertIsNone(result)
@ -158,7 +158,7 @@ class TestDeleteNetworkAgent(TestNetworkAgent):
calls = []
for n in self.network_agents:
calls.append(call(n.id, ignore_missing=False))
self.network.delete_agent.assert_has_calls(calls)
self.network_client.delete_agent.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_network_agents_delete_with_exception(self):
@ -175,7 +175,9 @@ class TestDeleteNetworkAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
delete_mock_result = [True, exceptions.CommandError]
self.network.delete_agent = mock.Mock(side_effect=delete_mock_result)
self.network_client.delete_agent = mock.Mock(
side_effect=delete_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -183,10 +185,10 @@ class TestDeleteNetworkAgent(TestNetworkAgent):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 network agents failed to delete.', str(e))
self.network.delete_agent.assert_any_call(
self.network_client.delete_agent.assert_any_call(
self.network_agents[0].id, ignore_missing=False
)
self.network.delete_agent.assert_any_call(
self.network_client.delete_agent.assert_any_call(
'unexist_network_agent', ignore_missing=False
)
@ -219,22 +221,28 @@ class TestListNetworkAgent(TestNetworkAgent):
def setUp(self):
super(TestListNetworkAgent, self).setUp()
self.network.agents = mock.Mock(return_value=self.network_agents)
_testagent = network_fakes.create_one_network_agent()
self.network.get_agent = mock.Mock(return_value=_testagent)
self._testnetwork = network_fakes.create_one_network()
self.network.find_network = mock.Mock(return_value=self._testnetwork)
self.network.network_hosting_dhcp_agents = mock.Mock(
self.network_client.agents = mock.Mock(
return_value=self.network_agents
)
self.network.get_agent = mock.Mock(return_value=_testagent)
_testagent = network_fakes.create_one_network_agent()
self.network_client.get_agent = mock.Mock(return_value=_testagent)
self._testnetwork = network_fakes.create_one_network()
self.network_client.find_network = mock.Mock(
return_value=self._testnetwork
)
self.network_client.network_hosting_dhcp_agents = mock.Mock(
return_value=self.network_agents
)
self.network_client.get_agent = mock.Mock(return_value=_testagent)
self._testrouter = network_fakes.FakeRouter.create_one_router()
self.network.find_router = mock.Mock(return_value=self._testrouter)
self.network.routers_hosting_l3_agents = mock.Mock(
self.network_client.find_router = mock.Mock(
return_value=self._testrouter
)
self.network_client.routers_hosting_l3_agents = mock.Mock(
return_value=self.network_agents
)
@ -248,7 +256,7 @@ class TestListNetworkAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.agents.assert_called_once_with(**{})
self.network_client.agents.assert_called_once_with(**{})
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -264,7 +272,7 @@ class TestListNetworkAgent(TestNetworkAgent):
columns, data = self.cmd.take_action(parsed_args)
self.network.agents.assert_called_once_with(
self.network_client.agents.assert_called_once_with(
**{
'agent_type': 'DHCP agent',
}
@ -284,7 +292,7 @@ class TestListNetworkAgent(TestNetworkAgent):
columns, data = self.cmd.take_action(parsed_args)
self.network.agents.assert_called_once_with(
self.network_client.agents.assert_called_once_with(
**{
'host': self.network_agents[0].host,
}
@ -304,7 +312,7 @@ class TestListNetworkAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.network_hosting_dhcp_agents.assert_called_once_with(
self.network_client.network_hosting_dhcp_agents.assert_called_once_with(
self._testnetwork
)
self.assertEqual(self.columns, columns)
@ -324,7 +332,9 @@ class TestListNetworkAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers_hosting_l3_agents.assert_called_once_with(*attrs)
self.network_client.routers_hosting_l3_agents.assert_called_once_with(
*attrs
)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -344,7 +354,9 @@ class TestListNetworkAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers_hosting_l3_agents.assert_called_once_with(*attrs)
self.network_client.routers_hosting_l3_agents.assert_called_once_with(
*attrs
)
# Add a column 'HA State' and corresponding data.
router_agent_columns = self.columns + ('HA State',)
@ -361,10 +373,10 @@ class TestRemoveNetworkFromAgent(TestNetworkAgent):
def setUp(self):
super(TestRemoveNetworkFromAgent, self).setUp()
self.network.get_agent = mock.Mock(return_value=self.agent)
self.network.find_network = mock.Mock(return_value=self.net)
self.network.name = self.network.find_network.name
self.network.remove_dhcp_agent_from_network = mock.Mock()
self.network_client.get_agent = mock.Mock(return_value=self.agent)
self.network_client.find_network = mock.Mock(return_value=self.net)
self.network_client.name = self.network_client.find_network.name
self.network_client.remove_dhcp_agent_from_network = mock.Mock()
self.cmd = network_agent.RemoveNetworkFromAgent(
self.app, self.namespace
)
@ -408,7 +420,7 @@ class TestRemoveNetworkFromAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.remove_dhcp_agent_from_network.assert_called_once_with(
self.network_client.remove_dhcp_agent_from_network.assert_called_once_with(
self.agent, self.net
)
@ -419,12 +431,12 @@ class TestRemoveRouterAgent(TestNetworkAgent):
def setUp(self):
super(TestRemoveRouterAgent, self).setUp()
self.network.remove_router_from_agent = mock.Mock()
self.network_client.remove_router_from_agent = mock.Mock()
self.cmd = network_agent.RemoveRouterFromAgent(
self.app, self.namespace
)
self.network.get_agent = mock.Mock(return_value=self._agent)
self.network.find_router = mock.Mock(return_value=self._router)
self.network_client.get_agent = mock.Mock(return_value=self._agent)
self.network_client.find_router = mock.Mock(return_value=self._router)
def test_remove_no_options(self):
arglist = []
@ -454,7 +466,7 @@ class TestRemoveRouterAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.remove_router_from_agent.assert_called_with(
self.network_client.remove_router_from_agent.assert_called_with(
self._agent, self._router
)
self.assertIsNone(result)
@ -465,8 +477,10 @@ class TestSetNetworkAgent(TestNetworkAgent):
def setUp(self):
super(TestSetNetworkAgent, self).setUp()
self.network.update_agent = mock.Mock(return_value=None)
self.network.get_agent = mock.Mock(return_value=self._network_agent)
self.network_client.update_agent = mock.Mock(return_value=None)
self.network_client.get_agent = mock.Mock(
return_value=self._network_agent
)
# Get the command object to test
self.cmd = network_agent.SetNetworkAgent(self.app, self.namespace)
@ -483,7 +497,7 @@ class TestSetNetworkAgent(TestNetworkAgent):
result = self.cmd.take_action(parsed_args)
attrs = {}
self.network.update_agent.assert_called_once_with(
self.network_client.update_agent.assert_called_once_with(
self._network_agent, **attrs
)
self.assertIsNone(result)
@ -510,7 +524,7 @@ class TestSetNetworkAgent(TestNetworkAgent):
'admin_state_up': True,
'is_admin_state_up': True,
}
self.network.update_agent.assert_called_once_with(
self.network_client.update_agent.assert_called_once_with(
self._network_agent, **attrs
)
self.assertIsNone(result)
@ -533,7 +547,7 @@ class TestSetNetworkAgent(TestNetworkAgent):
'admin_state_up': False,
'is_admin_state_up': False,
}
self.network.update_agent.assert_called_once_with(
self.network_client.update_agent.assert_called_once_with(
self._network_agent, **attrs
)
self.assertIsNone(result)
@ -579,7 +593,9 @@ class TestShowNetworkAgent(TestNetworkAgent):
def setUp(self):
super(TestShowNetworkAgent, self).setUp()
self.network.get_agent = mock.Mock(return_value=self._network_agent)
self.network_client.get_agent = mock.Mock(
return_value=self._network_agent
)
# Get the command object to test
self.cmd = network_agent.ShowNetworkAgent(self.app, self.namespace)
@ -608,6 +624,8 @@ class TestShowNetworkAgent(TestNetworkAgent):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_agent.assert_called_once_with(self._network_agent.id)
self.network_client.get_agent.assert_called_once_with(
self._network_agent.id
)
self.assertEqual(set(self.columns), set(columns))
self.assertEqual(len(list(self.data)), len(list(data)))

34
openstackclient/tests/unit/network/v2/test_network_auto_allocated_topology.py

@ -23,7 +23,7 @@ from openstackclient.tests.unit.network.v2 import fakes as network_fakes
class TestAutoAllocatedTopology(network_fakes.TestNetworkV2):
def setUp(self):
super(TestAutoAllocatedTopology, self).setUp()
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.projects_mock = self.app.client_manager.identity.projects
@ -51,7 +51,7 @@ class TestCreateAutoAllocatedTopology(TestAutoAllocatedTopology):
self.cmd = network_auto_allocated_topology.CreateAutoAllocatedTopology(
self.app, self.namespace
)
self.network.get_auto_allocated_topology = mock.Mock(
self.network_client.get_auto_allocated_topology = mock.Mock(
return_value=self.topology
)
@ -62,7 +62,9 @@ class TestCreateAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_auto_allocated_topology.assert_called_with(None)
self.network_client.get_auto_allocated_topology.assert_called_with(
None
)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
@ -80,7 +82,7 @@ class TestCreateAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_auto_allocated_topology.assert_called_with(
self.network_client.get_auto_allocated_topology.assert_called_with(
self.project.id
)
@ -103,7 +105,7 @@ class TestCreateAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_auto_allocated_topology.assert_called_with(
self.network_client.get_auto_allocated_topology.assert_called_with(
self.project.id
)
@ -122,7 +124,9 @@ class TestCreateAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_auto_allocated_topology.assert_called_with(None)
self.network_client.get_auto_allocated_topology.assert_called_with(
None
)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
@ -152,7 +156,7 @@ class TestValidateAutoAllocatedTopology(TestAutoAllocatedTopology):
self.cmd = network_auto_allocated_topology.CreateAutoAllocatedTopology(
self.app, self.namespace
)
self.network.validate_auto_allocated_topology = mock.Mock(
self.network_client.validate_auto_allocated_topology = mock.Mock(
return_value=self.topology
)
@ -167,7 +171,9 @@ class TestValidateAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.validate_auto_allocated_topology.assert_called_with(None)
self.network_client.validate_auto_allocated_topology.assert_called_with(
None
)
def test_show_dry_run_project_option(self):
arglist = [
@ -183,7 +189,7 @@ class TestValidateAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.validate_auto_allocated_topology.assert_called_with(
self.network_client.validate_auto_allocated_topology.assert_called_with(
self.project.id
)
@ -204,7 +210,7 @@ class TestValidateAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.validate_auto_allocated_topology.assert_called_with(
self.network_client.validate_auto_allocated_topology.assert_called_with(
self.project.id
)
@ -223,7 +229,7 @@ class TestDeleteAutoAllocatedTopology(TestAutoAllocatedTopology):
self.cmd = network_auto_allocated_topology.DeleteAutoAllocatedTopology(
self.app, self.namespace
)
self.network.delete_auto_allocated_topology = mock.Mock(
self.network_client.delete_auto_allocated_topology = mock.Mock(
return_value=None
)
@ -234,7 +240,7 @@ class TestDeleteAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_auto_allocated_topology.assert_called_once_with(
self.network_client.delete_auto_allocated_topology.assert_called_once_with(
None
)
@ -252,7 +258,7 @@ class TestDeleteAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_auto_allocated_topology.assert_called_once_with(
self.network_client.delete_auto_allocated_topology.assert_called_once_with(
self.project.id
)
@ -273,7 +279,7 @@ class TestDeleteAutoAllocatedTopology(TestAutoAllocatedTopology):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_auto_allocated_topology.assert_called_once_with(
self.network_client.delete_auto_allocated_topology.assert_called_once_with(
self.project.id
)

72
openstackclient/tests/unit/network/v2/test_network_flavor.py

@ -29,7 +29,7 @@ class TestNetworkFlavor(network_fakes.TestNetworkV2):
super(TestNetworkFlavor, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -42,11 +42,13 @@ class TestAddNetworkFlavorToProfile(TestNetworkFlavor):
def setUp(self):
super(TestAddNetworkFlavorToProfile, self).setUp()
self.network.find_flavor = mock.Mock(return_value=self.network_flavor)
self.network.find_service_profile = mock.Mock(
self.network_client.find_flavor = mock.Mock(
return_value=self.network_flavor
)
self.network_client.find_service_profile = mock.Mock(
return_value=self.service_profile
)
self.network.associate_flavor_with_service_profile = mock.Mock()
self.network_client.associate_flavor_with_service_profile = mock.Mock()
self.cmd = network_flavor.AddNetworkFlavorToProfile(
self.app, self.namespace
@ -75,7 +77,7 @@ class TestAddNetworkFlavorToProfile(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.associate_flavor_with_service_profile.assert_called_once_with( # noqa: E501
self.network_client.associate_flavor_with_service_profile.assert_called_once_with( # noqa: E501
self.network_flavor, self.service_profile
)
@ -104,7 +106,7 @@ class TestCreateNetworkFlavor(TestNetworkFlavor):
def setUp(self):
super(TestCreateNetworkFlavor, self).setUp()
self.network.create_flavor = mock.Mock(
self.network_client.create_flavor = mock.Mock(
return_value=self.new_network_flavor
)
@ -141,7 +143,7 @@ class TestCreateNetworkFlavor(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_flavor.assert_called_once_with(
self.network_client.create_flavor.assert_called_once_with(
**{
'service_type': self.new_network_flavor.service_type,
'name': self.new_network_flavor.name,
@ -175,7 +177,7 @@ class TestCreateNetworkFlavor(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_flavor.assert_called_once_with(
self.network_client.create_flavor.assert_called_once_with(
**{
'description': self.new_network_flavor.description,
'enabled': True,
@ -203,7 +205,7 @@ class TestCreateNetworkFlavor(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_flavor.assert_called_once_with(
self.network_client.create_flavor.assert_called_once_with(
**{
'enabled': False,
'service_type': self.new_network_flavor.service_type,
@ -220,8 +222,8 @@ class TestDeleteNetworkFlavor(TestNetworkFlavor):
def setUp(self):
super(TestDeleteNetworkFlavor, self).setUp()
self.network.delete_flavor = mock.Mock(return_value=None)
self.network.find_flavor = network_fakes.get_flavor(
self.network_client.delete_flavor = mock.Mock(return_value=None)
self.network_client.find_flavor = network_fakes.get_flavor(
network_flavors=self._network_flavors
)
@ -239,10 +241,10 @@ class TestDeleteNetworkFlavor(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_flavor.assert_called_once_with(
self.network_client.find_flavor.assert_called_once_with(
self._network_flavors[0].name, ignore_missing=False
)
self.network.delete_flavor.assert_called_once_with(
self.network_client.delete_flavor.assert_called_once_with(
self._network_flavors[0]
)
self.assertIsNone(result)
@ -263,7 +265,7 @@ class TestDeleteNetworkFlavor(TestNetworkFlavor):
calls = []
for a in self._network_flavors:
calls.append(mock.call(a))
self.network.delete_flavor.assert_has_calls(calls)
self.network_client.delete_flavor.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_network_flavors_delete_with_exception(self):
@ -280,7 +282,9 @@ class TestDeleteNetworkFlavor(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._network_flavors[0], exceptions.CommandError]
self.network.find_flavor = mock.Mock(side_effect=find_mock_result)
self.network_client.find_flavor = mock.Mock(
side_effect=find_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -288,13 +292,13 @@ class TestDeleteNetworkFlavor(TestNetworkFlavor):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 flavors failed to delete.', str(e))
self.network.find_flavor.assert_any_call(
self.network_client.find_flavor.assert_any_call(
self._network_flavors[0].name, ignore_missing=False
)
self.network.find_flavor.assert_any_call(
self.network_client.find_flavor.assert_any_call(
'unexist_network_flavor', ignore_missing=False
)
self.network.delete_flavor.assert_called_once_with(
self.network_client.delete_flavor.assert_called_once_with(
self._network_flavors[0]
)
@ -323,7 +327,9 @@ class TestListNetworkFlavor(TestNetworkFlavor):
def setUp(self):
super(TestListNetworkFlavor, self).setUp()
self.network.flavors = mock.Mock(return_value=self._network_flavors)
self.network_client.flavors = mock.Mock(
return_value=self._network_flavors
)
# Get the command object to test
self.cmd = network_flavor.ListNetworkFlavor(self.app, self.namespace)
@ -335,7 +341,7 @@ class TestListNetworkFlavor(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.flavors.assert_called_once_with(**{})
self.network_client.flavors.assert_called_once_with(**{})
self.assertEqual(set(self.columns), set(columns))
self.assertEqual(self.data, list(data))
@ -346,11 +352,15 @@ class TestRemoveNetworkFlavorFromProfile(TestNetworkFlavor):
def setUp(self):
super(TestRemoveNetworkFlavorFromProfile, self).setUp()
self.network.find_flavor = mock.Mock(return_value=self.network_flavor)
self.network.find_service_profile = mock.Mock(
self.network_client.find_flavor = mock.Mock(
return_value=self.network_flavor
)
self.network_client.find_service_profile = mock.Mock(
return_value=self.service_profile
)
self.network.disassociate_flavor_from_service_profile = mock.Mock()
self.network_client.disassociate_flavor_from_service_profile = (
mock.Mock()
)
self.cmd = network_flavor.RemoveNetworkFlavorFromProfile(
self.app, self.namespace
@ -379,7 +389,7 @@ class TestRemoveNetworkFlavorFromProfile(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.cmd.take_action(parsed_args)
self.network.disassociate_flavor_from_service_profile.assert_called_once_with( # noqa: E501
self.network_client.disassociate_flavor_from_service_profile.assert_called_once_with( # noqa: E501
self.network_flavor, self.service_profile
)
@ -406,7 +416,7 @@ class TestShowNetworkFlavor(TestNetworkFlavor):
def setUp(self):
super(TestShowNetworkFlavor, self).setUp()
self.network.find_flavor = mock.Mock(
self.network_client.find_flavor = mock.Mock(
return_value=self.new_network_flavor
)
@ -437,7 +447,7 @@ class TestShowNetworkFlavor(TestNetworkFlavor):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_flavor.assert_called_once_with(
self.network_client.find_flavor.assert_called_once_with(
self.new_network_flavor.name, ignore_missing=False
)
self.assertEqual(set(self.columns), set(columns))
@ -450,8 +460,8 @@ class TestSetNetworkFlavor(TestNetworkFlavor):
def setUp(self):
super(TestSetNetworkFlavor, self).setUp()
self.network.update_flavor = mock.Mock(return_value=None)
self.network.find_flavor = mock.Mock(
self.network_client.update_flavor = mock.Mock(return_value=None)
self.network_client.find_flavor = mock.Mock(
return_value=self.new_network_flavor
)
@ -470,7 +480,7 @@ class TestSetNetworkFlavor(TestNetworkFlavor):
result = self.cmd.take_action(parsed_args)
attrs = {}
self.network.update_flavor.assert_called_with(
self.network_client.update_flavor.assert_called_with(
self.new_network_flavor, **attrs
)
self.assertIsNone(result)
@ -494,7 +504,7 @@ class TestSetNetworkFlavor(TestNetworkFlavor):
'name': "new_network_flavor",
'enabled': True,
}
self.network.update_flavor.assert_called_with(
self.network_client.update_flavor.assert_called_with(
self.new_network_flavor, **attrs
)
self.assertIsNone(result)
@ -514,7 +524,7 @@ class TestSetNetworkFlavor(TestNetworkFlavor):
attrs = {
'enabled': False,
}
self.network.update_flavor.assert_called_with(
self.network_client.update_flavor.assert_called_with(
self.new_network_flavor, **attrs
)
self.assertIsNone(result)

56
openstackclient/tests/unit/network/v2/test_network_flavor_profile.py

@ -23,7 +23,7 @@ class TestFlavorProfile(network_fakes.TestNetworkV2):
def setUp(self):
super(TestFlavorProfile, self).setUp()
# Get the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get the DomainManager Mock
@ -55,7 +55,7 @@ class TestCreateFlavorProfile(TestFlavorProfile):
def setUp(self):
super(TestCreateFlavorProfile, self).setUp()
self.network.create_service_profile = mock.Mock(
self.network_client.create_service_profile = mock.Mock(
return_value=self.new_flavor_profile
)
self.projects_mock.get.return_value = self.project
@ -91,7 +91,7 @@ class TestCreateFlavorProfile(TestFlavorProfile):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_service_profile.assert_called_once_with(
self.network_client.create_service_profile.assert_called_once_with(
**{
'description': self.new_flavor_profile.description,
'project_id': self.project.id,
@ -127,7 +127,7 @@ class TestCreateFlavorProfile(TestFlavorProfile):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_service_profile.assert_called_once_with(
self.network_client.create_service_profile.assert_called_once_with(
**{
'description': self.new_flavor_profile.description,
'project_id': self.project.id,
@ -162,7 +162,7 @@ class TestCreateFlavorProfile(TestFlavorProfile):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_service_profile.assert_called_once_with(
self.network_client.create_service_profile.assert_called_once_with(
**{
'description': self.new_flavor_profile.description,
'project_id': self.project.id,
@ -213,7 +213,7 @@ class TestCreateFlavorProfile(TestFlavorProfile):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_service_profile.assert_called_once_with(
self.network_client.create_service_profile.assert_called_once_with(
**{
'enabled': False,
'driver': self.new_flavor_profile.driver,
@ -229,9 +229,13 @@ class TestDeleteFlavorProfile(TestFlavorProfile):
def setUp(self):
super(TestDeleteFlavorProfile, self).setUp()
self.network.delete_service_profile = mock.Mock(return_value=None)
self.network.find_service_profile = network_fakes.get_service_profile(
flavor_profile=self._network_flavor_profiles
self.network_client.delete_service_profile = mock.Mock(
return_value=None
)
self.network_client.find_service_profile = (
network_fakes.get_service_profile(
flavor_profile=self._network_flavor_profiles
)
)
# Get the command object to test
@ -250,10 +254,10 @@ class TestDeleteFlavorProfile(TestFlavorProfile):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_service_profile.assert_called_once_with(
self.network_client.find_service_profile.assert_called_once_with(
self._network_flavor_profiles[0].id, ignore_missing=False
)
self.network.delete_service_profile.assert_called_once_with(
self.network_client.delete_service_profile.assert_called_once_with(
self._network_flavor_profiles[0]
)
self.assertIsNone(result)
@ -273,7 +277,7 @@ class TestDeleteFlavorProfile(TestFlavorProfile):
calls = []
for a in self._network_flavor_profiles:
calls.append(mock.call(a))
self.network.delete_service_profile.assert_has_calls(calls)
self.network_client.delete_service_profile.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_network_flavor_profiles_delete_with_exception(self):
@ -296,7 +300,7 @@ class TestDeleteFlavorProfile(TestFlavorProfile):
self._network_flavor_profiles[0],
exceptions.CommandError,
]
self.network.find_service_profile = mock.Mock(
self.network_client.find_service_profile = mock.Mock(
side_effect=find_mock_result
)
@ -308,13 +312,13 @@ class TestDeleteFlavorProfile(TestFlavorProfile):
'1 of 2 flavor_profiles failed to delete.', str(e)
)
self.network.find_service_profile.assert_any_call(
self.network_client.find_service_profile.assert_any_call(
self._network_flavor_profiles[0].id, ignore_missing=False
)
self.network.find_service_profile.assert_any_call(
self.network_client.find_service_profile.assert_any_call(
'unexist_network_flavor_profile', ignore_missing=False
)
self.network.delete_service_profile.assert_called_once_with(
self.network_client.delete_service_profile.assert_called_once_with(
self._network_flavor_profiles[0]
)
@ -344,7 +348,7 @@ class TestListFlavorProfile(TestFlavorProfile):
def setUp(self):
super(TestListFlavorProfile, self).setUp()
self.network.service_profiles = mock.Mock(
self.network_client.service_profiles = mock.Mock(
return_value=self._network_flavor_profiles
)
@ -360,7 +364,7 @@ class TestListFlavorProfile(TestFlavorProfile):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.service_profiles.assert_called_once_with(**{})
self.network_client.service_profiles.assert_called_once_with(**{})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -387,7 +391,7 @@ class TestShowFlavorProfile(TestFlavorProfile):
def setUp(self):
super(TestShowFlavorProfile, self).setUp()
self.network.find_service_profile = mock.Mock(
self.network_client.find_service_profile = mock.Mock(
return_value=self.network_flavor_profile
)
@ -407,7 +411,7 @@ class TestShowFlavorProfile(TestFlavorProfile):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_service_profile.assert_called_once_with(
self.network_client.find_service_profile.assert_called_once_with(
self.network_flavor_profile.id, ignore_missing=False
)
self.assertEqual(self.columns, columns)
@ -420,8 +424,10 @@ class TestSetFlavorProfile(TestFlavorProfile):
def setUp(self):
super(TestSetFlavorProfile, self).setUp()
self.network.update_service_profile = mock.Mock(return_value=None)
self.network.find_service_profile = mock.Mock(
self.network_client.update_service_profile = mock.Mock(
return_value=None
)
self.network_client.find_service_profile = mock.Mock(
return_value=self.network_flavor_profile
)
@ -440,7 +446,7 @@ class TestSetFlavorProfile(TestFlavorProfile):
result = self.cmd.take_action(parsed_args)
attrs = {}
self.network.update_service_profile.assert_called_with(
self.network_client.update_service_profile.assert_called_with(
self.network_flavor_profile, **attrs
)
self.assertIsNone(result)
@ -460,7 +466,7 @@ class TestSetFlavorProfile(TestFlavorProfile):
attrs = {
'enabled': True,
}
self.network.update_service_profile.assert_called_with(
self.network_client.update_service_profile.assert_called_with(
self.network_flavor_profile, **attrs
)
self.assertIsNone(result)
@ -480,7 +486,7 @@ class TestSetFlavorProfile(TestFlavorProfile):
attrs = {
'enabled': False,
}
self.network.update_service_profile.assert_called_with(
self.network_client.update_service_profile.assert_called_with(
self.network_flavor_profile, **attrs
)
self.assertIsNone(result)

36
openstackclient/tests/unit/network/v2/test_network_meter.py

@ -27,7 +27,7 @@ from openstackclient.tests.unit import utils as tests_utils
class TestMeter(network_fakes.TestNetworkV2):
def setUp(self):
super(TestMeter, self).setUp()
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.projects_mock = self.app.client_manager.identity.projects
self.domains_mock = self.app.client_manager.identity.domains
@ -55,7 +55,7 @@ class TestCreateMeter(TestMeter):
def setUp(self):
super(TestCreateMeter, self).setUp()
self.network.create_metering_label = mock.Mock(
self.network_client.create_metering_label = mock.Mock(
return_value=self.new_meter
)
self.projects_mock.get.return_value = self.project
@ -85,7 +85,7 @@ class TestCreateMeter(TestMeter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_metering_label.assert_called_once_with(
self.network_client.create_metering_label.assert_called_once_with(
**{'name': self.new_meter.name}
)
self.assertEqual(self.columns, columns)
@ -114,7 +114,7 @@ class TestCreateMeter(TestMeter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_metering_label.assert_called_once_with(
self.network_client.create_metering_label.assert_called_once_with(
**{
'description': self.new_meter.description,
'name': self.new_meter.name,
@ -132,9 +132,11 @@ class TestDeleteMeter(TestMeter):
self.meter_list = network_fakes.FakeNetworkMeter.create_meter(count=2)
self.network.delete_metering_label = mock.Mock(return_value=None)
self.network_client.delete_metering_label = mock.Mock(
return_value=None
)
self.network.find_metering_label = (
self.network_client.find_metering_label = (
network_fakes.FakeNetworkMeter.get_meter(meter=self.meter_list)
)
@ -152,7 +154,7 @@ class TestDeleteMeter(TestMeter):
result = self.cmd.take_action(parsed_args)
self.network.delete_metering_label.assert_called_once_with(
self.network_client.delete_metering_label.assert_called_once_with(
self.meter_list[0]
)
self.assertIsNone(result)
@ -172,7 +174,7 @@ class TestDeleteMeter(TestMeter):
calls = []
for n in self.meter_list:
calls.append(call(n))
self.network.delete_metering_label.assert_has_calls(calls)
self.network_client.delete_metering_label.assert_has_calls(calls)
self.assertIsNone(result)
def test_delete_multiple_meter_exception(self):
@ -192,13 +194,15 @@ class TestDeleteMeter(TestMeter):
exceptions.NotFound('404'),
self.meter_list[1],
]
self.network.find_meter = mock.Mock(side_effect=return_find)
self.network_client.find_meter = mock.Mock(side_effect=return_find)
ret_delete = [
None,
exceptions.NotFound('404'),
]
self.network.delete_metering_label = mock.Mock(side_effect=ret_delete)
self.network_client.delete_metering_label = mock.Mock(
side_effect=ret_delete
)
self.assertRaises(
exceptions.CommandError, self.cmd.take_action, parsed_args
@ -208,7 +212,7 @@ class TestDeleteMeter(TestMeter):
call(self.meter_list[0]),
call(self.meter_list[1]),
]
self.network.delete_metering_label.assert_has_calls(calls)
self.network_client.delete_metering_label.assert_has_calls(calls)
class TestListMeter(TestMeter):
@ -236,7 +240,9 @@ class TestListMeter(TestMeter):
def setUp(self):
super(TestListMeter, self).setUp()
self.network.metering_labels = mock.Mock(return_value=self.meter_list)
self.network_client.metering_labels = mock.Mock(
return_value=self.meter_list
)
self.cmd = network_meter.ListMeter(self.app, self.namespace)
@ -248,7 +254,7 @@ class TestListMeter(TestMeter):
columns, data = self.cmd.take_action(parsed_args)
self.network.metering_labels.assert_called_with()
self.network_client.metering_labels.assert_called_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -276,7 +282,7 @@ class TestShowMeter(TestMeter):
self.cmd = network_meter.ShowMeter(self.app, self.namespace)
self.network.find_metering_label = mock.Mock(
self.network_client.find_metering_label = mock.Mock(
return_value=self.new_meter
)
@ -303,7 +309,7 @@ class TestShowMeter(TestMeter):
columns, data = self.cmd.take_action(parsed_args)
self.network.find_metering_label.assert_called_with(
self.network_client.find_metering_label.assert_called_with(
self.new_meter.name, ignore_missing=False
)
self.assertEqual(self.columns, columns)

36
openstackclient/tests/unit/network/v2/test_network_meter_rule.py

@ -27,7 +27,7 @@ from openstackclient.tests.unit import utils as tests_utils
class TestMeterRule(network_fakes.TestNetworkV2):
def setUp(self):
super(TestMeterRule, self).setUp()
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.projects_mock = self.app.client_manager.identity.projects
self.domains_mock = self.app.client_manager.identity.domains
@ -65,12 +65,14 @@ class TestCreateMeterRule(TestMeterRule):
{'id': self.new_rule.metering_label_id}
)
self.network.create_metering_label_rule = mock.Mock(
self.network_client.create_metering_label_rule = mock.Mock(
return_value=self.new_rule
)
self.projects_mock.get.return_value = self.project
self.cmd = network_meter_rule.CreateMeterRule(self.app, self.namespace)
self.network.find_metering_label = mock.Mock(return_value=fake_meter)
self.network_client.find_metering_label = mock.Mock(
return_value=fake_meter
)
def test_create_no_options(self):
arglist = []
@ -98,7 +100,7 @@ class TestCreateMeterRule(TestMeterRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_metering_label_rule.assert_called_once_with(
self.network_client.create_metering_label_rule.assert_called_once_with(
**{
'direction': 'ingress',
'metering_label_id': self.new_rule.metering_label_id,
@ -126,7 +128,7 @@ class TestCreateMeterRule(TestMeterRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_metering_label_rule.assert_called_once_with(
self.network_client.create_metering_label_rule.assert_called_once_with(
**{
'direction': self.new_rule.direction,
'excluded': self.new_rule.excluded,
@ -144,9 +146,11 @@ class TestDeleteMeterRule(TestMeterRule):
self.rule_list = network_fakes.FakeNetworkMeterRule.create_meter_rule(
count=2
)
self.network.delete_metering_label_rule = mock.Mock(return_value=None)
self.network_client.delete_metering_label_rule = mock.Mock(
return_value=None
)
self.network.find_metering_label_rule = (
self.network_client.find_metering_label_rule = (
network_fakes.FakeNetworkMeterRule.get_meter_rule(
meter_rule=self.rule_list
)
@ -166,7 +170,7 @@ class TestDeleteMeterRule(TestMeterRule):
result = self.cmd.take_action(parsed_args)
self.network.delete_metering_label_rule.assert_called_once_with(
self.network_client.delete_metering_label_rule.assert_called_once_with(
self.rule_list[0]
)
self.assertIsNone(result)
@ -186,7 +190,7 @@ class TestDeleteMeterRule(TestMeterRule):
calls = []
for rule in self.rule_list:
calls.append(call(rule))
self.network.delete_metering_label_rule.assert_has_calls(calls)
self.network_client.delete_metering_label_rule.assert_has_calls(calls)
self.assertIsNone(result)
def test_delete_multiple_rules_exception(self):
@ -206,7 +210,7 @@ class TestDeleteMeterRule(TestMeterRule):
exceptions.NotFound('404'),
self.rule_list[1],
]
self.network.find_metering_label_rule = mock.Mock(
self.network_client.find_metering_label_rule = mock.Mock(
side_effect=return_find
)
@ -214,7 +218,7 @@ class TestDeleteMeterRule(TestMeterRule):
None,
exceptions.NotFound('404'),
]
self.network.delete_metering_label_rule = mock.Mock(
self.network_client.delete_metering_label_rule = mock.Mock(
side_effect=ret_delete
)
@ -226,7 +230,7 @@ class TestDeleteMeterRule(TestMeterRule):
call(self.rule_list[0]),
call(self.rule_list[1]),
]
self.network.delete_metering_label_rule.assert_has_calls(calls)
self.network_client.delete_metering_label_rule.assert_has_calls(calls)
class TestListMeterRule(TestMeterRule):
@ -258,7 +262,7 @@ class TestListMeterRule(TestMeterRule):
def setUp(self):
super(TestListMeterRule, self).setUp()
self.network.metering_label_rules = mock.Mock(
self.network_client.metering_label_rules = mock.Mock(
return_value=self.rule_list
)
@ -272,7 +276,7 @@ class TestListMeterRule(TestMeterRule):
columns, data = self.cmd.take_action(parsed_args)
self.network.metering_label_rules.assert_called_with()
self.network_client.metering_label_rules.assert_called_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -307,7 +311,7 @@ class TestShowMeterRule(TestMeterRule):
self.cmd = network_meter_rule.ShowMeterRule(self.app, self.namespace)
self.network.find_metering_label_rule = mock.Mock(
self.network_client.find_metering_label_rule = mock.Mock(
return_value=self.new_rule
)
@ -334,7 +338,7 @@ class TestShowMeterRule(TestMeterRule):
columns, data = self.cmd.take_action(parsed_args)
self.network.find_metering_label_rule.assert_called_with(
self.network_client.find_metering_label_rule.assert_called_with(
self.new_rule.id, ignore_missing=False
)
self.assertEqual(self.columns, columns)

62
openstackclient/tests/unit/network/v2/test_network_qos_policy.py

@ -28,7 +28,7 @@ class TestQosPolicy(network_fakes.TestNetworkV2):
def setUp(self):
super(TestQosPolicy, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
@ -64,7 +64,7 @@ class TestCreateNetworkQosPolicy(TestQosPolicy):
def setUp(self):
super(TestCreateNetworkQosPolicy, self).setUp()
self.network.create_qos_policy = mock.Mock(
self.network_client.create_qos_policy = mock.Mock(
return_value=self.new_qos_policy
)
@ -100,7 +100,7 @@ class TestCreateNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_qos_policy.assert_called_once_with(
self.network_client.create_qos_policy.assert_called_once_with(
**{'name': self.new_qos_policy.name}
)
self.assertEqual(self.columns, columns)
@ -127,7 +127,7 @@ class TestCreateNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_qos_policy.assert_called_once_with(
self.network_client.create_qos_policy.assert_called_once_with(
**{
'shared': True,
'project_id': self.project.id,
@ -150,7 +150,7 @@ class TestCreateNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_qos_policy.assert_called_once_with(
self.network_client.create_qos_policy.assert_called_once_with(
**{
'name': self.new_qos_policy.name,
'is_default': False,
@ -168,8 +168,8 @@ class TestDeleteNetworkQosPolicy(TestQosPolicy):
def setUp(self):
super(TestDeleteNetworkQosPolicy, self).setUp()
self.network.delete_qos_policy = mock.Mock(return_value=None)
self.network.find_qos_policy = (
self.network_client.delete_qos_policy = mock.Mock(return_value=None)
self.network_client.find_qos_policy = (
network_fakes.FakeNetworkQosPolicy.get_qos_policies(
qos_policies=self._qos_policies
)
@ -191,10 +191,10 @@ class TestDeleteNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_qos_policy.assert_called_once_with(
self.network_client.find_qos_policy.assert_called_once_with(
self._qos_policies[0].name, ignore_missing=False
)
self.network.delete_qos_policy.assert_called_once_with(
self.network_client.delete_qos_policy.assert_called_once_with(
self._qos_policies[0]
)
self.assertIsNone(result)
@ -214,7 +214,7 @@ class TestDeleteNetworkQosPolicy(TestQosPolicy):
calls = []
for a in self._qos_policies:
calls.append(call(a))
self.network.delete_qos_policy.assert_has_calls(calls)
self.network_client.delete_qos_policy.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_qos_policies_delete_with_exception(self):
@ -228,7 +228,7 @@ class TestDeleteNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._qos_policies[0], exceptions.CommandError]
self.network.find_qos_policy = mock.MagicMock(
self.network_client.find_qos_policy = mock.MagicMock(
side_effect=find_mock_result
)
@ -238,13 +238,13 @@ class TestDeleteNetworkQosPolicy(TestQosPolicy):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 QoS policies failed to delete.', str(e))
self.network.find_qos_policy.assert_any_call(
self.network_client.find_qos_policy.assert_any_call(
self._qos_policies[0].name, ignore_missing=False
)
self.network.find_qos_policy.assert_any_call(
self.network_client.find_qos_policy.assert_any_call(
'unexist_qos_policy', ignore_missing=False
)
self.network.delete_qos_policy.assert_called_once_with(
self.network_client.delete_qos_policy.assert_called_once_with(
self._qos_policies[0]
)
@ -275,7 +275,9 @@ class TestListNetworkQosPolicy(TestQosPolicy):
def setUp(self):
super(TestListNetworkQosPolicy, self).setUp()
self.network.qos_policies = mock.Mock(return_value=self.qos_policies)
self.network_client.qos_policies = mock.Mock(
return_value=self.qos_policies
)
# Get the command object to test
self.cmd = network_qos_policy.ListNetworkQosPolicy(
@ -289,7 +291,7 @@ class TestListNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.qos_policies.assert_called_once_with(**{})
self.network_client.qos_policies.assert_called_once_with(**{})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -304,7 +306,9 @@ class TestListNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.qos_policies.assert_called_once_with(**{'shared': True})
self.network_client.qos_policies.assert_called_once_with(
**{'shared': True}
)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -318,7 +322,9 @@ class TestListNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.qos_policies.assert_called_once_with(**{'shared': False})
self.network_client.qos_policies.assert_called_once_with(
**{'shared': False}
)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -337,7 +343,7 @@ class TestListNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.qos_policies.assert_called_once_with(
self.network_client.qos_policies.assert_called_once_with(
**{'project_id': project.id}
)
@ -351,8 +357,10 @@ class TestSetNetworkQosPolicy(TestQosPolicy):
def setUp(self):
super(TestSetNetworkQosPolicy, self).setUp()
self.network.update_qos_policy = mock.Mock(return_value=None)
self.network.find_qos_policy = mock.Mock(return_value=self._qos_policy)
self.network_client.update_qos_policy = mock.Mock(return_value=None)
self.network_client.find_qos_policy = mock.Mock(
return_value=self._qos_policy
)
# Get the command object to test
self.cmd = network_qos_policy.SetNetworkQosPolicy(
@ -371,7 +379,7 @@ class TestSetNetworkQosPolicy(TestQosPolicy):
result = self.cmd.take_action(parsed_args)
attrs = {}
self.network.update_qos_policy.assert_called_with(
self.network_client.update_qos_policy.assert_called_with(
self._qos_policy, **attrs
)
self.assertIsNone(result)
@ -402,7 +410,7 @@ class TestSetNetworkQosPolicy(TestQosPolicy):
'shared': True,
'is_default': True,
}
self.network.update_qos_policy.assert_called_with(
self.network_client.update_qos_policy.assert_called_with(
self._qos_policy, **attrs
)
self.assertIsNone(result)
@ -422,7 +430,7 @@ class TestSetNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {'shared': False, 'is_default': False}
self.network.update_qos_policy.assert_called_with(
self.network_client.update_qos_policy.assert_called_with(
self._qos_policy, **attrs
)
self.assertIsNone(result)
@ -452,7 +460,9 @@ class TestShowNetworkQosPolicy(TestQosPolicy):
def setUp(self):
super(TestShowNetworkQosPolicy, self).setUp()
self.network.find_qos_policy = mock.Mock(return_value=self._qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=self._qos_policy
)
# Get the command object to test
self.cmd = network_qos_policy.ShowNetworkQosPolicy(
@ -483,7 +493,7 @@ class TestShowNetworkQosPolicy(TestQosPolicy):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_qos_policy.assert_called_once_with(
self.network_client.find_qos_policy.assert_called_once_with(
self._qos_policy.name, ignore_missing=False
)
self.assertEqual(self.columns, columns)

150
openstackclient/tests/unit/network/v2/test_network_qos_rule.py

@ -55,11 +55,13 @@ class TestNetworkQosRule(network_fakes.TestNetworkV2):
def setUp(self):
super(TestNetworkQosRule, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.qos_policy = (
network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
class TestCreateNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
@ -92,7 +94,7 @@ class TestCreateNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
self.new_rule.qos_policy_id,
self.new_rule.type,
)
self.network.create_qos_minimum_bandwidth_rule = mock.Mock(
self.network_client.create_qos_minimum_bandwidth_rule = mock.Mock(
return_value=self.new_rule
)
@ -134,7 +136,7 @@ class TestCreateNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_qos_minimum_bandwidth_rule.assert_called_once_with(
self.network_client.create_qos_minimum_bandwidth_rule.assert_called_once_with(
self.qos_policy.id,
**{
'min_kbps': self.new_rule.min_kbps,
@ -201,7 +203,7 @@ class TestCreateNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
self.new_rule.qos_policy_id,
self.new_rule.type,
)
self.network.create_qos_minimum_packet_rate_rule = mock.Mock(
self.network_client.create_qos_minimum_packet_rate_rule = mock.Mock(
return_value=self.new_rule
)
@ -243,7 +245,7 @@ class TestCreateNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_qos_minimum_packet_rate_rule.assert_called_once_with( # noqa: E501
self.network_client.create_qos_minimum_packet_rate_rule.assert_called_once_with( # noqa: E501
self.qos_policy.id,
**{
'min_kpps': self.new_rule.min_kpps,
@ -308,7 +310,7 @@ class TestCreateNetworkQosRuleDSCPMarking(TestNetworkQosRule):
self.new_rule.qos_policy_id,
self.new_rule.type,
)
self.network.create_qos_dscp_marking_rule = mock.Mock(
self.network_client.create_qos_dscp_marking_rule = mock.Mock(
return_value=self.new_rule
)
@ -348,7 +350,7 @@ class TestCreateNetworkQosRuleDSCPMarking(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_qos_dscp_marking_rule.assert_called_once_with(
self.network_client.create_qos_dscp_marking_rule.assert_called_once_with(
self.qos_policy.id, **{'dscp_mark': self.new_rule.dscp_mark}
)
self.assertEqual(self.columns, columns)
@ -412,7 +414,7 @@ class TestCreateNetworkQosRuleBandwidtLimit(TestNetworkQosRule):
self.new_rule.qos_policy_id,
self.new_rule.type,
)
self.network.create_qos_bandwidth_limit_rule = mock.Mock(
self.network_client.create_qos_bandwidth_limit_rule = mock.Mock(
return_value=self.new_rule
)
@ -469,7 +471,9 @@ class TestCreateNetworkQosRuleBandwidtLimit(TestNetworkQosRule):
)
with mock.patch.object(
self.network, "create_qos_bandwidth_limit_rule", return_value=rule
self.network_client,
"create_qos_bandwidth_limit_rule",
return_value=rule,
) as create_qos_bandwidth_limit_rule:
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
@ -507,7 +511,7 @@ class TestCreateNetworkQosRuleBandwidtLimit(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_qos_bandwidth_limit_rule.assert_called_once_with(
self.network_client.create_qos_bandwidth_limit_rule.assert_called_once_with(
self.qos_policy.id,
**{
'max_kbps': self.new_rule.max_kbps,
@ -555,10 +559,10 @@ class TestDeleteNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.delete_qos_minimum_bandwidth_rule = mock.Mock(
self.network_client.delete_qos_minimum_bandwidth_rule = mock.Mock(
return_value=None
)
self.network.find_qos_minimum_bandwidth_rule = (
self.network_client.find_qos_minimum_bandwidth_rule = (
network_fakes.FakeNetworkQosRule.get_qos_rules(
qos_rules=self.new_rule
)
@ -581,10 +585,10 @@ class TestDeleteNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_qos_policy.assert_called_once_with(
self.network_client.find_qos_policy.assert_called_once_with(
self.qos_policy.id, ignore_missing=False
)
self.network.delete_qos_minimum_bandwidth_rule.assert_called_once_with(
self.network_client.delete_qos_minimum_bandwidth_rule.assert_called_once_with(
self.new_rule.id, self.qos_policy.id
)
self.assertIsNone(result)
@ -599,8 +603,8 @@ class TestDeleteNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
('id', self.new_rule.id),
]
self.network.delete_qos_minimum_bandwidth_rule.side_effect = Exception(
'Error message'
self.network_client.delete_qos_minimum_bandwidth_rule.side_effect = (
Exception('Error message')
)
try:
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@ -624,10 +628,10 @@ class TestDeleteNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.delete_qos_minimum_packet_rate_rule = mock.Mock(
self.network_client.delete_qos_minimum_packet_rate_rule = mock.Mock(
return_value=None
)
self.network.find_qos_minimum_packet_rate_rule = (
self.network_client.find_qos_minimum_packet_rate_rule = (
network_fakes.FakeNetworkQosRule.get_qos_rules(
qos_rules=self.new_rule
)
@ -650,10 +654,10 @@ class TestDeleteNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_qos_policy.assert_called_once_with(
self.network_client.find_qos_policy.assert_called_once_with(
self.qos_policy.id, ignore_missing=False
)
self.network.delete_qos_minimum_packet_rate_rule.assert_called_once_with( # noqa: E501
self.network_client.delete_qos_minimum_packet_rate_rule.assert_called_once_with( # noqa: E501
self.new_rule.id, self.qos_policy.id
)
self.assertIsNone(result)
@ -668,7 +672,7 @@ class TestDeleteNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
('id', self.new_rule.id),
]
self.network.delete_qos_minimum_packet_rate_rule.side_effect = (
self.network_client.delete_qos_minimum_packet_rate_rule.side_effect = (
Exception('Error message')
)
try:
@ -693,10 +697,10 @@ class TestDeleteNetworkQosRuleDSCPMarking(TestNetworkQosRule):
attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.delete_qos_dscp_marking_rule = mock.Mock(
self.network_client.delete_qos_dscp_marking_rule = mock.Mock(
return_value=None
)
self.network.find_qos_dscp_marking_rule = (
self.network_client.find_qos_dscp_marking_rule = (
network_fakes.FakeNetworkQosRule.get_qos_rules(
qos_rules=self.new_rule
)
@ -719,10 +723,10 @@ class TestDeleteNetworkQosRuleDSCPMarking(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_qos_policy.assert_called_once_with(
self.network_client.find_qos_policy.assert_called_once_with(
self.qos_policy.id, ignore_missing=False
)
self.network.delete_qos_dscp_marking_rule.assert_called_once_with(
self.network_client.delete_qos_dscp_marking_rule.assert_called_once_with(
self.new_rule.id, self.qos_policy.id
)
self.assertIsNone(result)
@ -737,8 +741,8 @@ class TestDeleteNetworkQosRuleDSCPMarking(TestNetworkQosRule):
('id', self.new_rule.id),
]
self.network.delete_qos_dscp_marking_rule.side_effect = Exception(
'Error message'
self.network_client.delete_qos_dscp_marking_rule.side_effect = (
Exception('Error message')
)
try:
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@ -762,10 +766,10 @@ class TestDeleteNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.delete_qos_bandwidth_limit_rule = mock.Mock(
self.network_client.delete_qos_bandwidth_limit_rule = mock.Mock(
return_value=None
)
self.network.find_qos_bandwidth_limit_rule = (
self.network_client.find_qos_bandwidth_limit_rule = (
network_fakes.FakeNetworkQosRule.get_qos_rules(
qos_rules=self.new_rule
)
@ -788,10 +792,10 @@ class TestDeleteNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_qos_policy.assert_called_once_with(
self.network_client.find_qos_policy.assert_called_once_with(
self.qos_policy.id, ignore_missing=False
)
self.network.delete_qos_bandwidth_limit_rule.assert_called_once_with(
self.network_client.delete_qos_bandwidth_limit_rule.assert_called_once_with(
self.new_rule.id, self.qos_policy.id
)
self.assertIsNone(result)
@ -806,8 +810,8 @@ class TestDeleteNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
('id', self.new_rule.id),
]
self.network.delete_qos_bandwidth_limit_rule.side_effect = Exception(
'Error message'
self.network_client.delete_qos_bandwidth_limit_rule.side_effect = (
Exception('Error message')
)
try:
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@ -831,13 +835,15 @@ class TestSetNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
attrs=attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.update_qos_minimum_bandwidth_rule = mock.Mock(
self.network_client.update_qos_minimum_bandwidth_rule = mock.Mock(
return_value=None
)
self.network.find_qos_minimum_bandwidth_rule = mock.Mock(
self.network_client.find_qos_minimum_bandwidth_rule = mock.Mock(
return_value=self.new_rule
)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
# Get the command object to test
self.cmd = network_qos_rule.SetNetworkQosRule(self.app, self.namespace)
@ -855,7 +861,7 @@ class TestSetNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_qos_minimum_bandwidth_rule.assert_called_with(
self.network_client.update_qos_minimum_bandwidth_rule.assert_called_with(
self.new_rule, self.qos_policy.id
)
self.assertIsNone(result)
@ -889,7 +895,7 @@ class TestSetNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
attrs = {
'min_kbps': self.new_rule.min_kbps,
}
self.network.update_qos_minimum_bandwidth_rule.assert_called_with(
self.network_client.update_qos_minimum_bandwidth_rule.assert_called_with(
self.new_rule, self.qos_policy.id, **attrs
)
self.assertIsNone(result)
@ -933,13 +939,15 @@ class TestSetNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
attrs=attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.update_qos_minimum_packet_rate_rule = mock.Mock(
self.network_client.update_qos_minimum_packet_rate_rule = mock.Mock(
return_value=None
)
self.network.find_qos_minimum_packet_rate_rule = mock.Mock(
self.network_client.find_qos_minimum_packet_rate_rule = mock.Mock(
return_value=self.new_rule
)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
# Get the command object to test
self.cmd = network_qos_rule.SetNetworkQosRule(self.app, self.namespace)
@ -957,7 +965,7 @@ class TestSetNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_qos_minimum_packet_rate_rule.assert_called_with(
self.network_client.update_qos_minimum_packet_rate_rule.assert_called_with(
self.new_rule, self.qos_policy.id
)
self.assertIsNone(result)
@ -991,7 +999,7 @@ class TestSetNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
attrs = {
'min_kpps': self.new_rule.min_kpps,
}
self.network.update_qos_minimum_packet_rate_rule.assert_called_with(
self.network_client.update_qos_minimum_packet_rate_rule.assert_called_with(
self.new_rule, self.qos_policy.id, **attrs
)
self.assertIsNone(result)
@ -1035,13 +1043,15 @@ class TestSetNetworkQosRuleDSCPMarking(TestNetworkQosRule):
attrs=attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.update_qos_dscp_marking_rule = mock.Mock(
self.network_client.update_qos_dscp_marking_rule = mock.Mock(
return_value=None
)
self.network.find_qos_dscp_marking_rule = mock.Mock(
self.network_client.find_qos_dscp_marking_rule = mock.Mock(
return_value=self.new_rule
)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
# Get the command object to test
self.cmd = network_qos_rule.SetNetworkQosRule(self.app, self.namespace)
@ -1059,7 +1069,7 @@ class TestSetNetworkQosRuleDSCPMarking(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_qos_dscp_marking_rule.assert_called_with(
self.network_client.update_qos_dscp_marking_rule.assert_called_with(
self.new_rule, self.qos_policy.id
)
self.assertIsNone(result)
@ -1093,7 +1103,7 @@ class TestSetNetworkQosRuleDSCPMarking(TestNetworkQosRule):
attrs = {
'dscp_mark': self.new_rule.dscp_mark,
}
self.network.update_qos_dscp_marking_rule.assert_called_with(
self.network_client.update_qos_dscp_marking_rule.assert_called_with(
self.new_rule, self.qos_policy.id, **attrs
)
self.assertIsNone(result)
@ -1137,13 +1147,15 @@ class TestSetNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
attrs=attrs
)
self.qos_policy.rules = [self.new_rule]
self.network.update_qos_bandwidth_limit_rule = mock.Mock(
self.network_client.update_qos_bandwidth_limit_rule = mock.Mock(
return_value=None
)
self.network.find_qos_bandwidth_limit_rule = mock.Mock(
self.network_client.find_qos_bandwidth_limit_rule = mock.Mock(
return_value=self.new_rule
)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_policy
)
# Get the command object to test
self.cmd = network_qos_rule.SetNetworkQosRule(self.app, self.namespace)
@ -1161,7 +1173,7 @@ class TestSetNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_qos_bandwidth_limit_rule.assert_called_with(
self.network_client.update_qos_bandwidth_limit_rule.assert_called_with(
self.new_rule, self.qos_policy.id
)
self.assertIsNone(result)
@ -1198,7 +1210,7 @@ class TestSetNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
attrs = {
'max_kbps': self.new_rule.max_kbps,
}
self.network.update_qos_bandwidth_limit_rule.assert_called_with(
self.network_client.update_qos_bandwidth_limit_rule.assert_called_with(
self.new_rule, self.qos_policy.id, **attrs
)
self.assertIsNone(result)
@ -1237,7 +1249,7 @@ class TestSetNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
attrs = {
'max_burst_kbps': self.new_rule.max_burst_kbits,
}
self.network.update_qos_bandwidth_limit_rule.assert_called_with(
self.network_client.update_qos_bandwidth_limit_rule.assert_called_with(
self.new_rule, self.qos_policy.id, **attrs
)
self.assertIsNone(result)
@ -1271,7 +1283,7 @@ class TestSetNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
attrs = {
'direction': direction,
}
self.network.update_qos_bandwidth_limit_rule.assert_called_with(
self.network_client.update_qos_bandwidth_limit_rule.assert_called_with(
self.new_rule, self.qos_policy.id, **attrs
)
self.assertIsNone(result)
@ -1329,16 +1341,16 @@ class TestListNetworkQosRule(TestNetworkQosRule):
self.new_rule_dscp_mark,
self.new_rule_max_bw,
]
self.network.find_qos_minimum_bandwidth_rule = mock.Mock(
self.network_client.find_qos_minimum_bandwidth_rule = mock.Mock(
return_value=self.new_rule_min_bw
)
self.network.find_qos_minimum_packet_rate_rule = mock.Mock(
self.network_client.find_qos_minimum_packet_rate_rule = mock.Mock(
return_value=self.new_rule_min_pps
)
self.network.find_qos_dscp_marking_rule = mock.Mock(
self.network_client.find_qos_dscp_marking_rule = mock.Mock(
return_value=self.new_rule_dscp_mark
)
self.network.find_qos_bandwidth_limit_rule = mock.Mock(
self.network_client.find_qos_bandwidth_limit_rule = mock.Mock(
return_value=self.new_rule_max_bw
)
self.columns = (
@ -1383,7 +1395,7 @@ class TestListNetworkQosRule(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_qos_policy.assert_called_once_with(
self.network_client.find_qos_policy.assert_called_once_with(
self.qos_policy.id, ignore_missing=False
)
self.assertEqual(self.columns, columns)
@ -1421,7 +1433,7 @@ class TestShowNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
self.new_rule.type,
)
self.network.get_qos_minimum_bandwidth_rule = mock.Mock(
self.network_client.get_qos_minimum_bandwidth_rule = mock.Mock(
return_value=self.new_rule
)
@ -1456,7 +1468,7 @@ class TestShowNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_qos_minimum_bandwidth_rule.assert_called_once_with(
self.network_client.get_qos_minimum_bandwidth_rule.assert_called_once_with(
self.new_rule.id, self.qos_policy.id
)
self.assertEqual(self.columns, columns)
@ -1491,7 +1503,7 @@ class TestShowNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
self.new_rule.type,
)
self.network.get_qos_minimum_packet_rate_rule = mock.Mock(
self.network_client.get_qos_minimum_packet_rate_rule = mock.Mock(
return_value=self.new_rule
)
@ -1526,7 +1538,7 @@ class TestShowNetworkQosRuleMinimumPacketRate(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_qos_minimum_packet_rate_rule.assert_called_once_with(
self.network_client.get_qos_minimum_packet_rate_rule.assert_called_once_with(
self.new_rule.id, self.qos_policy.id
)
self.assertEqual(self.columns, columns)
@ -1559,7 +1571,7 @@ class TestShowNetworkQosDSCPMarking(TestNetworkQosRule):
self.new_rule.type,
)
self.network.get_qos_dscp_marking_rule = mock.Mock(
self.network_client.get_qos_dscp_marking_rule = mock.Mock(
return_value=self.new_rule
)
@ -1594,7 +1606,7 @@ class TestShowNetworkQosDSCPMarking(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_qos_dscp_marking_rule.assert_called_once_with(
self.network_client.get_qos_dscp_marking_rule.assert_called_once_with(
self.new_rule.id, self.qos_policy.id
)
self.assertEqual(self.columns, columns)
@ -1631,7 +1643,7 @@ class TestShowNetworkQosBandwidthLimit(TestNetworkQosRule):
self.new_rule.type,
)
self.network.get_qos_bandwidth_limit_rule = mock.Mock(
self.network_client.get_qos_bandwidth_limit_rule = mock.Mock(
return_value=self.new_rule
)
@ -1666,7 +1678,7 @@ class TestShowNetworkQosBandwidthLimit(TestNetworkQosRule):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_qos_bandwidth_limit_rule.assert_called_once_with(
self.network_client.get_qos_bandwidth_limit_rule.assert_called_once_with(
self.new_rule.id, self.qos_policy.id
)
self.assertEqual(self.columns, columns)

14
openstackclient/tests/unit/network/v2/test_network_qos_rule_type.py

@ -24,7 +24,7 @@ class TestNetworkQosRuleType(network_fakes.TestNetworkV2):
def setUp(self):
super(TestNetworkQosRuleType, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
class TestShowNetworkQosRuleType(TestNetworkQosRuleType):
@ -38,7 +38,7 @@ class TestShowNetworkQosRuleType(TestNetworkQosRuleType):
def setUp(self):
super(TestShowNetworkQosRuleType, self).setUp()
self.network.get_qos_rule_type = mock.Mock(
self.network_client.get_qos_rule_type = mock.Mock(
return_value=self.qos_rule_type
)
@ -71,7 +71,7 @@ class TestShowNetworkQosRuleType(TestNetworkQosRuleType):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_qos_rule_type.assert_called_once_with(
self.network_client.get_qos_rule_type.assert_called_once_with(
self.qos_rule_type.type
)
self.assertEqual(self.columns, columns)
@ -90,7 +90,7 @@ class TestListNetworkQosRuleType(TestNetworkQosRuleType):
def setUp(self):
super(TestListNetworkQosRuleType, self).setUp()
self.network.qos_rule_types = mock.Mock(
self.network_client.qos_rule_types = mock.Mock(
return_value=self.qos_rule_types
)
@ -106,7 +106,7 @@ class TestListNetworkQosRuleType(TestNetworkQosRuleType):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.qos_rule_types.assert_called_once_with(**{})
self.network_client.qos_rule_types.assert_called_once_with(**{})
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -119,7 +119,7 @@ class TestListNetworkQosRuleType(TestNetworkQosRuleType):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.qos_rule_types.assert_called_once_with(
self.network_client.qos_rule_types.assert_called_once_with(
**{'all_supported': True}
)
self.assertEqual(self.columns, columns)
@ -134,7 +134,7 @@ class TestListNetworkQosRuleType(TestNetworkQosRuleType):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.qos_rule_types.assert_called_once_with(
self.network_client.qos_rule_types.assert_called_once_with(
**{'all_rules': True}
)
self.assertEqual(self.columns, columns)

80
openstackclient/tests/unit/network/v2/test_network_rbac.py

@ -28,7 +28,7 @@ class TestNetworkRBAC(network_fakes.TestNetworkV2):
super(TestNetworkRBAC, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
@ -74,19 +74,25 @@ class TestCreateNetworkRBAC(TestNetworkRBAC):
# Get the command object to test
self.cmd = network_rbac.CreateNetworkRBAC(self.app, self.namespace)
self.network.create_rbac_policy = mock.Mock(
self.network_client.create_rbac_policy = mock.Mock(
return_value=self.rbac_policy
)
self.network.find_network = mock.Mock(return_value=self.network_object)
self.network.find_qos_policy = mock.Mock(return_value=self.qos_object)
self.network.find_security_group = mock.Mock(
self.network_client.find_network = mock.Mock(
return_value=self.network_object
)
self.network_client.find_qos_policy = mock.Mock(
return_value=self.qos_object
)
self.network_client.find_security_group = mock.Mock(
return_value=self.sg_object
)
self.network.find_address_scope = mock.Mock(
self.network_client.find_address_scope = mock.Mock(
return_value=self.as_object
)
self.network.find_subnet_pool = mock.Mock(return_value=self.snp_object)
self.network.find_address_group = mock.Mock(
self.network_client.find_subnet_pool = mock.Mock(
return_value=self.snp_object
)
self.network_client.find_address_group = mock.Mock(
return_value=self.ag_object
)
self.projects_mock.get.return_value = self.project
@ -200,7 +206,7 @@ class TestCreateNetworkRBAC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.create_rbac_policy.assert_called_with(
self.network_client.create_rbac_policy.assert_called_with(
**{
'object_id': self.rbac_policy.object_id,
'object_type': self.rbac_policy.object_type,
@ -230,7 +236,7 @@ class TestCreateNetworkRBAC(TestNetworkRBAC):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_rbac_policy.assert_called_with(
self.network_client.create_rbac_policy.assert_called_with(
**{
'object_id': self.rbac_policy.object_id,
'object_type': self.rbac_policy.object_type,
@ -269,7 +275,7 @@ class TestCreateNetworkRBAC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.create_rbac_policy.assert_called_with(
self.network_client.create_rbac_policy.assert_called_with(
**{
'object_id': self.rbac_policy.object_id,
'object_type': self.rbac_policy.object_type,
@ -314,7 +320,7 @@ class TestCreateNetworkRBAC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.create_rbac_policy.assert_called_with(
self.network_client.create_rbac_policy.assert_called_with(
**{
'object_id': obj_fake.id,
'object_type': obj_type,
@ -339,8 +345,8 @@ class TestDeleteNetworkRBAC(TestNetworkRBAC):
def setUp(self):
super(TestDeleteNetworkRBAC, self).setUp()
self.network.delete_rbac_policy = mock.Mock(return_value=None)
self.network.find_rbac_policy = network_fakes.get_network_rbacs(
self.network_client.delete_rbac_policy = mock.Mock(return_value=None)
self.network_client.find_rbac_policy = network_fakes.get_network_rbacs(
rbac_policies=self.rbac_policies
)
@ -358,10 +364,10 @@ class TestDeleteNetworkRBAC(TestNetworkRBAC):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_rbac_policy.assert_called_once_with(
self.network_client.find_rbac_policy.assert_called_once_with(
self.rbac_policies[0].id, ignore_missing=False
)
self.network.delete_rbac_policy.assert_called_once_with(
self.network_client.delete_rbac_policy.assert_called_once_with(
self.rbac_policies[0]
)
self.assertIsNone(result)
@ -382,7 +388,7 @@ class TestDeleteNetworkRBAC(TestNetworkRBAC):
calls = []
for r in self.rbac_policies:
calls.append(call(r))
self.network.delete_rbac_policy.assert_has_calls(calls)
self.network_client.delete_rbac_policy.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_network_policies_delete_with_exception(self):
@ -396,7 +402,9 @@ class TestDeleteNetworkRBAC(TestNetworkRBAC):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self.rbac_policies[0], exceptions.CommandError]
self.network.find_rbac_policy = mock.Mock(side_effect=find_mock_result)
self.network_client.find_rbac_policy = mock.Mock(
side_effect=find_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -404,13 +412,13 @@ class TestDeleteNetworkRBAC(TestNetworkRBAC):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 RBAC policies failed to delete.', str(e))
self.network.find_rbac_policy.assert_any_call(
self.network_client.find_rbac_policy.assert_any_call(
self.rbac_policies[0].id, ignore_missing=False
)
self.network.find_rbac_policy.assert_any_call(
self.network_client.find_rbac_policy.assert_any_call(
'unexist_rbac_policy', ignore_missing=False
)
self.network.delete_rbac_policy.assert_called_once_with(
self.network_client.delete_rbac_policy.assert_called_once_with(
self.rbac_policies[0]
)
@ -456,7 +464,9 @@ class TestListNetworkRABC(TestNetworkRBAC):
# Get the command object to test
self.cmd = network_rbac.ListNetworkRBAC(self.app, self.namespace)
self.network.rbac_policies = mock.Mock(return_value=self.rbac_policies)
self.network_client.rbac_policies = mock.Mock(
return_value=self.rbac_policies
)
self.project = identity_fakes_v3.FakeProject.create_one_project()
self.projects_mock.get.return_value = self.project
@ -469,7 +479,7 @@ class TestListNetworkRABC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.rbac_policies.assert_called_with()
self.network_client.rbac_policies.assert_called_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -484,7 +494,7 @@ class TestListNetworkRABC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.rbac_policies.assert_called_with(
self.network_client.rbac_policies.assert_called_with(
**{'object_type': self.rbac_policies[0].object_type}
)
self.assertEqual(self.columns, columns)
@ -501,7 +511,7 @@ class TestListNetworkRABC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.rbac_policies.assert_called_with(
self.network_client.rbac_policies.assert_called_with(
**{'action': self.rbac_policies[0].action}
)
self.assertEqual(self.columns, columns)
@ -520,7 +530,7 @@ class TestListNetworkRABC(TestNetworkRBAC):
columns, data = self.cmd.take_action(parsed_args)
self.network.rbac_policies.assert_called_with()
self.network_client.rbac_policies.assert_called_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
@ -537,7 +547,7 @@ class TestListNetworkRABC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.rbac_policies.assert_called_with(
self.network_client.rbac_policies.assert_called_with(
**{'target_project_id': self.project.id}
)
self.assertEqual(self.columns, columns)
@ -556,10 +566,10 @@ class TestSetNetworkRBAC(TestNetworkRBAC):
# Get the command object to test
self.cmd = network_rbac.SetNetworkRBAC(self.app, self.namespace)
self.network.find_rbac_policy = mock.Mock(
self.network_client.find_rbac_policy = mock.Mock(
return_value=self.rbac_policy
)
self.network.update_rbac_policy = mock.Mock(return_value=None)
self.network_client.update_rbac_policy = mock.Mock(return_value=None)
self.projects_mock.get.return_value = self.project
def test_network_rbac_set_nothing(self):
@ -572,11 +582,11 @@ class TestSetNetworkRBAC(TestNetworkRBAC):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_rbac_policy.assert_called_once_with(
self.network_client.find_rbac_policy.assert_called_once_with(
self.rbac_policy.id, ignore_missing=False
)
attrs = {}
self.network.update_rbac_policy.assert_called_once_with(
self.network_client.update_rbac_policy.assert_called_once_with(
self.rbac_policy, **attrs
)
self.assertIsNone(result)
@ -594,11 +604,11 @@ class TestSetNetworkRBAC(TestNetworkRBAC):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.find_rbac_policy.assert_called_once_with(
self.network_client.find_rbac_policy.assert_called_once_with(
self.rbac_policy.id, ignore_missing=False
)
attrs = {'target_tenant': self.project.id}
self.network.update_rbac_policy.assert_called_once_with(
self.network_client.update_rbac_policy.assert_called_once_with(
self.rbac_policy, **attrs
)
self.assertIsNone(result)
@ -631,7 +641,7 @@ class TestShowNetworkRBAC(TestNetworkRBAC):
# Get the command object to test
self.cmd = network_rbac.ShowNetworkRBAC(self.app, self.namespace)
self.network.find_rbac_policy = mock.Mock(
self.network_client.find_rbac_policy = mock.Mock(
return_value=self.rbac_policy
)
@ -659,7 +669,7 @@ class TestShowNetworkRBAC(TestNetworkRBAC):
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
self.network.find_rbac_policy.assert_called_with(
self.network_client.find_rbac_policy.assert_called_with(
self.rbac_policy.id, ignore_missing=False
)
self.assertEqual(self.columns, columns)

60
openstackclient/tests/unit/network/v2/test_network_segment.py

@ -26,7 +26,7 @@ class TestNetworkSegment(network_fakes.TestNetworkV2):
super(TestNetworkSegment, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
class TestCreateNetworkSegment(TestNetworkSegment):
@ -61,10 +61,12 @@ class TestCreateNetworkSegment(TestNetworkSegment):
def setUp(self):
super(TestCreateNetworkSegment, self).setUp()
self.network.create_segment = mock.Mock(
self.network_client.create_segment = mock.Mock(
return_value=self._network_segment
)
self.network.find_network = mock.Mock(return_value=self._network)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
# Get the command object to test
self.cmd = network_segment.CreateNetworkSegment(
@ -110,10 +112,10 @@ class TestCreateNetworkSegment(TestNetworkSegment):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_network.assert_called_once_with(
self.network_client.find_network.assert_called_once_with(
self._network_segment.network_id, ignore_missing=False
)
self.network.create_segment.assert_called_once_with(
self.network_client.create_segment.assert_called_once_with(
**{
'network_id': self._network_segment.network_id,
'network_type': self._network_segment.network_type,
@ -150,10 +152,10 @@ class TestCreateNetworkSegment(TestNetworkSegment):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_network.assert_called_once_with(
self.network_client.find_network.assert_called_once_with(
self._network_segment.network_id, ignore_missing=False
)
self.network.create_segment.assert_called_once_with(
self.network_client.create_segment.assert_called_once_with(
**{
'description': self._network_segment.description,
'network_id': self._network_segment.network_id,
@ -175,8 +177,8 @@ class TestDeleteNetworkSegment(TestNetworkSegment):
def setUp(self):
super(TestDeleteNetworkSegment, self).setUp()
self.network.delete_segment = mock.Mock(return_value=None)
self.network.find_segment = mock.Mock(
self.network_client.delete_segment = mock.Mock(return_value=None)
self.network_client.find_segment = mock.Mock(
side_effect=self._network_segments
)
@ -196,7 +198,7 @@ class TestDeleteNetworkSegment(TestNetworkSegment):
result = self.cmd.take_action(parsed_args)
self.network.delete_segment.assert_called_once_with(
self.network_client.delete_segment.assert_called_once_with(
self._network_segments[0]
)
self.assertIsNone(result)
@ -215,7 +217,7 @@ class TestDeleteNetworkSegment(TestNetworkSegment):
calls = []
for _network_segment in self._network_segments:
calls.append(call(_network_segment))
self.network.delete_segment.assert_has_calls(calls)
self.network_client.delete_segment.assert_has_calls(calls)
self.assertIsNone(result)
def test_delete_multiple_with_exception(self):
@ -229,7 +231,9 @@ class TestDeleteNetworkSegment(TestNetworkSegment):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._network_segments[0], exceptions.CommandError]
self.network.find_segment = mock.Mock(side_effect=find_mock_result)
self.network_client.find_segment = mock.Mock(
side_effect=find_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -239,13 +243,13 @@ class TestDeleteNetworkSegment(TestNetworkSegment):
'1 of 2 network segments failed to delete.', str(e)
)
self.network.find_segment.assert_any_call(
self.network_client.find_segment.assert_any_call(
self._network_segments[0].id, ignore_missing=False
)
self.network.find_segment.assert_any_call(
self.network_client.find_segment.assert_any_call(
'doesnotexist', ignore_missing=False
)
self.network.delete_segment.assert_called_once_with(
self.network_client.delete_segment.assert_called_once_with(
self._network_segments[0]
)
@ -294,8 +298,12 @@ class TestListNetworkSegment(TestNetworkSegment):
# Get the command object to test
self.cmd = network_segment.ListNetworkSegment(self.app, self.namespace)
self.network.find_network = mock.Mock(return_value=self._network)
self.network.segments = mock.Mock(return_value=self._network_segments)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
self.network_client.segments = mock.Mock(
return_value=self._network_segments
)
def test_list_no_option(self):
arglist = []
@ -307,7 +315,7 @@ class TestListNetworkSegment(TestNetworkSegment):
columns, data = self.cmd.take_action(parsed_args)
self.network.segments.assert_called_once_with()
self.network_client.segments.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -323,7 +331,7 @@ class TestListNetworkSegment(TestNetworkSegment):
columns, data = self.cmd.take_action(parsed_args)
self.network.segments.assert_called_once_with()
self.network_client.segments.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
@ -337,7 +345,7 @@ class TestListNetworkSegment(TestNetworkSegment):
columns, data = self.cmd.take_action(parsed_args)
self.network.segments.assert_called_once_with(
self.network_client.segments.assert_called_once_with(
**{'network_id': self._network.id}
)
self.assertEqual(self.columns, columns)
@ -351,10 +359,10 @@ class TestSetNetworkSegment(TestNetworkSegment):
def setUp(self):
super(TestSetNetworkSegment, self).setUp()
self.network.find_segment = mock.Mock(
self.network_client.find_segment = mock.Mock(
return_value=self._network_segment
)
self.network.update_segment = mock.Mock(
self.network_client.update_segment = mock.Mock(
return_value=self._network_segment
)
@ -372,7 +380,7 @@ class TestSetNetworkSegment(TestNetworkSegment):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_segment.assert_called_once_with(
self.network_client.update_segment.assert_called_once_with(
self._network_segment, **{}
)
self.assertIsNone(result)
@ -398,7 +406,7 @@ class TestSetNetworkSegment(TestNetworkSegment):
'description': 'new description',
'name': 'new name',
}
self.network.update_segment.assert_called_once_with(
self.network_client.update_segment.assert_called_once_with(
self._network_segment, **attrs
)
self.assertIsNone(result)
@ -431,7 +439,7 @@ class TestShowNetworkSegment(TestNetworkSegment):
def setUp(self):
super(TestShowNetworkSegment, self).setUp()
self.network.find_segment = mock.Mock(
self.network_client.find_segment = mock.Mock(
return_value=self._network_segment
)
@ -455,7 +463,7 @@ class TestShowNetworkSegment(TestNetworkSegment):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_segment.assert_called_once_with(
self.network_client.find_segment.assert_called_once_with(
self._network_segment.id, ignore_missing=False
)

60
openstackclient/tests/unit/network/v2/test_network_segment_range.py

@ -43,7 +43,7 @@ class TestNetworkSegmentRange(network_fakes.TestNetworkV2):
super(TestNetworkSegmentRange, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
class TestCreateNetworkSegmentRange(TestNetworkSegmentRange):
@ -81,8 +81,8 @@ class TestCreateNetworkSegmentRange(TestNetworkSegmentRange):
def setUp(self):
super(TestCreateNetworkSegmentRange, self).setUp()
self.network.find_extension = mock.Mock()
self.network.create_network_segment_range = mock.Mock(
self.network_client.find_extension = mock.Mock()
self.network_client.create_network_segment_range = mock.Mock(
return_value=self._network_segment_range
)
@ -217,7 +217,7 @@ class TestCreateNetworkSegmentRange(TestNetworkSegmentRange):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_network_segment_range.assert_called_once_with(
self.network_client.create_network_segment_range.assert_called_once_with(
**{
'shared': True,
'network_type': 'vxlan',
@ -255,7 +255,7 @@ class TestCreateNetworkSegmentRange(TestNetworkSegmentRange):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_network_segment_range.assert_called_once_with(
self.network_client.create_network_segment_range.assert_called_once_with(
**{
'shared': False,
'project_id': mock.ANY,
@ -291,7 +291,7 @@ class TestCreateNetworkSegmentRange(TestNetworkSegmentRange):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_network_segment_range.assert_called_once_with(
self.network_client.create_network_segment_range.assert_called_once_with(
**{
'shared': True,
'network_type': 'vxlan',
@ -332,7 +332,7 @@ class TestCreateNetworkSegmentRange(TestNetworkSegmentRange):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_network_segment_range.assert_called_once_with(
self.network_client.create_network_segment_range.assert_called_once_with(
**{
'shared': self._network_segment_range.shared,
'project_id': mock.ANY,
@ -355,11 +355,11 @@ class TestDeleteNetworkSegmentRange(TestNetworkSegmentRange):
def setUp(self):
super(TestDeleteNetworkSegmentRange, self).setUp()
self.network.find_extension = mock.Mock()
self.network.delete_network_segment_range = mock.Mock(
self.network_client.find_extension = mock.Mock()
self.network_client.delete_network_segment_range = mock.Mock(
return_value=None
)
self.network.find_network_segment_range = mock.Mock(
self.network_client.find_network_segment_range = mock.Mock(
side_effect=self._network_segment_ranges
)
@ -379,7 +379,7 @@ class TestDeleteNetworkSegmentRange(TestNetworkSegmentRange):
result = self.cmd.take_action(parsed_args)
self.network.delete_network_segment_range.assert_called_once_with(
self.network_client.delete_network_segment_range.assert_called_once_with(
self._network_segment_ranges[0]
)
self.assertIsNone(result)
@ -398,7 +398,9 @@ class TestDeleteNetworkSegmentRange(TestNetworkSegmentRange):
calls = []
for _network_segment_range in self._network_segment_ranges:
calls.append(call(_network_segment_range))
self.network.delete_network_segment_range.assert_has_calls(calls)
self.network_client.delete_network_segment_range.assert_has_calls(
calls
)
self.assertIsNone(result)
def test_delete_multiple_with_exception(self):
@ -415,7 +417,7 @@ class TestDeleteNetworkSegmentRange(TestNetworkSegmentRange):
self._network_segment_ranges[0],
exceptions.CommandError,
]
self.network.find_network_segment_range = mock.Mock(
self.network_client.find_network_segment_range = mock.Mock(
side_effect=find_mock_result
)
@ -427,13 +429,13 @@ class TestDeleteNetworkSegmentRange(TestNetworkSegmentRange):
'1 of 2 network segment ranges failed to delete.', str(e)
)
self.network.find_network_segment_range.assert_any_call(
self.network_client.find_network_segment_range.assert_any_call(
self._network_segment_ranges[0].id, ignore_missing=False
)
self.network.find_network_segment_range.assert_any_call(
self.network_client.find_network_segment_range.assert_any_call(
'doesnotexist', ignore_missing=False
)
self.network.delete_network_segment_range.assert_called_once_with(
self.network_client.delete_network_segment_range.assert_called_once_with(
self._network_segment_ranges[0]
)
@ -501,8 +503,8 @@ class TestListNetworkSegmentRange(TestNetworkSegmentRange):
self.app, self.namespace
)
self.network.find_extension = mock.Mock()
self.network.network_segment_ranges = mock.Mock(
self.network_client.find_extension = mock.Mock()
self.network_client.network_segment_ranges = mock.Mock(
return_value=self._network_segment_ranges
)
@ -519,7 +521,7 @@ class TestListNetworkSegmentRange(TestNetworkSegmentRange):
columns, data = self.cmd.take_action(parsed_args)
self.network.network_segment_ranges.assert_called_once_with()
self.network_client.network_segment_ranges.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -538,7 +540,7 @@ class TestListNetworkSegmentRange(TestNetworkSegmentRange):
columns, data = self.cmd.take_action(parsed_args)
self.network.network_segment_ranges.assert_called_once_with()
self.network_client.network_segment_ranges.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
@ -571,8 +573,8 @@ class TestSetNetworkSegmentRange(TestNetworkSegmentRange):
def setUp(self):
super(TestSetNetworkSegmentRange, self).setUp()
self.network.find_extension = mock.Mock()
self.network.find_network_segment_range = mock.Mock(
self.network_client.find_extension = mock.Mock()
self.network_client.find_network_segment_range = mock.Mock(
return_value=self._network_segment_range
)
@ -590,12 +592,12 @@ class TestSetNetworkSegmentRange(TestNetworkSegmentRange):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.network.update_network_segment_range = mock.Mock(
self.network_client.update_network_segment_range = mock.Mock(
return_value=self._network_segment_range
)
result = self.cmd.take_action(parsed_args)
self.network.update_network_segment_range.assert_called_once_with(
self.network_client.update_network_segment_range.assert_called_once_with(
self._network_segment_range, **{}
)
self.assertIsNone(result)
@ -618,7 +620,7 @@ class TestSetNetworkSegmentRange(TestNetworkSegmentRange):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.network.update_network_segment_range = mock.Mock(
self.network_client.update_network_segment_range = mock.Mock(
return_value=self._network_segment_range_updated
)
result = self.cmd.take_action(parsed_args)
@ -628,7 +630,7 @@ class TestSetNetworkSegmentRange(TestNetworkSegmentRange):
'minimum': self.minimum_updated,
'maximum': self.maximum_updated,
}
self.network.update_network_segment_range.assert_called_once_with(
self.network_client.update_network_segment_range.assert_called_once_with(
self._network_segment_range, **attrs
)
self.assertIsNone(result)
@ -669,8 +671,8 @@ class TestShowNetworkSegmentRange(TestNetworkSegmentRange):
def setUp(self):
super(TestShowNetworkSegmentRange, self).setUp()
self.network.find_extension = mock.Mock()
self.network.find_network_segment_range = mock.Mock(
self.network_client.find_extension = mock.Mock()
self.network_client.find_network_segment_range = mock.Mock(
return_value=self._network_segment_range
)
@ -696,7 +698,7 @@ class TestShowNetworkSegmentRange(TestNetworkSegmentRange):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_network_segment_range.assert_called_once_with(
self.network_client.find_network_segment_range.assert_called_once_with(
self._network_segment_range.id, ignore_missing=False
)

6
openstackclient/tests/unit/network/v2/test_network_service_provider.py

@ -24,7 +24,7 @@ from openstackclient.tests.unit.network.v2 import fakes
class TestNetworkServiceProvider(fakes.TestNetworkV2):
def setUp(self):
super(TestNetworkServiceProvider, self).setUp()
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
class TestListNetworkServiceProvider(TestNetworkServiceProvider):
@ -53,7 +53,7 @@ class TestListNetworkServiceProvider(TestNetworkServiceProvider):
def setUp(self):
super(TestListNetworkServiceProvider, self).setUp()
self.network.service_providers = mock.Mock(
self.network_client.service_providers = mock.Mock(
return_value=self.provider_list
)
@ -69,6 +69,6 @@ class TestListNetworkServiceProvider(TestNetworkServiceProvider):
columns, data = self.cmd.take_action(parsed_args)
self.network.service_providers.assert_called_with()
self.network_client.service_providers.assert_called_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))

108
openstackclient/tests/unit/network/v2/test_network_trunk.py

@ -33,7 +33,7 @@ class TestNetworkTrunk(network_fakes.TestNetworkV2):
super().setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -88,8 +88,10 @@ class TestCreateNetworkTrunk(TestNetworkTrunk):
def setUp(self):
super().setUp()
self.network.create_trunk = mock.Mock(return_value=self.new_trunk)
self.network.find_port = mock.Mock(
self.network_client.create_trunk = mock.Mock(
return_value=self.new_trunk
)
self.network_client.find_port = mock.Mock(
side_effect=[self.parent_port, self.sub_port]
)
@ -125,7 +127,7 @@ class TestCreateNetworkTrunk(TestNetworkTrunk):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_trunk.assert_called_once_with(
self.network_client.create_trunk.assert_called_once_with(
**{
'name': self.new_trunk['name'],
'admin_state_up': self.new_trunk['admin_state_up'],
@ -175,7 +177,7 @@ class TestCreateNetworkTrunk(TestNetworkTrunk):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_trunk.assert_called_once_with(
self.network_client.create_trunk.assert_called_once_with(
**{
'name': self.new_trunk.name,
'description': self.new_trunk.description,
@ -247,7 +249,7 @@ class TestCreateNetworkTrunk(TestNetworkTrunk):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_trunk.assert_called_once_with(
self.network_client.create_trunk.assert_called_once_with(
**{
'name': self.new_trunk.name,
'admin_state_up': True,
@ -319,11 +321,11 @@ class TestDeleteNetworkTrunk(TestNetworkTrunk):
def setUp(self):
super().setUp()
self.network.find_trunk = mock.Mock(
self.network_client.find_trunk = mock.Mock(
side_effect=[self.new_trunks[0], self.new_trunks[1]]
)
self.network.delete_trunk = mock.Mock(return_value=None)
self.network.find_port = mock.Mock(
self.network_client.delete_trunk = mock.Mock(return_value=None)
self.network_client.find_port = mock.Mock(
side_effect=[self.parent_port, self.sub_port]
)
@ -343,7 +345,7 @@ class TestDeleteNetworkTrunk(TestNetworkTrunk):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_trunk.assert_called_once_with(
self.network_client.delete_trunk.assert_called_once_with(
self.new_trunks[0].id
)
self.assertIsNone(result)
@ -364,7 +366,7 @@ class TestDeleteNetworkTrunk(TestNetworkTrunk):
calls = []
for t in self.new_trunks:
calls.append(call(t.id))
self.network.delete_trunk.assert_has_calls(calls)
self.network_client.delete_trunk.assert_has_calls(calls)
self.assertIsNone(result)
def test_delete_trunk_multiple_with_exception(self):
@ -377,13 +379,13 @@ class TestDeleteNetworkTrunk(TestNetworkTrunk):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.network.find_trunk = mock.Mock(
self.network_client.find_trunk = mock.Mock(
side_effect=[self.new_trunks[0], exceptions.CommandError]
)
with testtools.ExpectedException(exceptions.CommandError) as e:
self.cmd.take_action(parsed_args)
self.assertEqual('1 of 2 trunks failed to delete.', str(e))
self.network.delete_trunk.assert_called_once_with(
self.network_client.delete_trunk.assert_called_once_with(
self.new_trunks[0].id
)
@ -418,8 +420,8 @@ class TestShowNetworkTrunk(TestNetworkTrunk):
def setUp(self):
super().setUp()
self.network.find_trunk = mock.Mock(return_value=self.new_trunk)
self.network.get_trunk = mock.Mock(return_value=self.new_trunk)
self.network_client.find_trunk = mock.Mock(return_value=self.new_trunk)
self.network_client.get_trunk = mock.Mock(return_value=self.new_trunk)
self.projects_mock.get.return_value = self.project
self.domains_mock.get.return_value = self.domain
@ -450,7 +452,9 @@ class TestShowNetworkTrunk(TestNetworkTrunk):
columns, data = self.cmd.take_action(parsed_args)
self.network.get_trunk.assert_called_once_with(self.new_trunk.id)
self.network_client.get_trunk.assert_called_once_with(
self.new_trunk.id
)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
@ -489,7 +493,7 @@ class TestListNetworkTrunk(TestNetworkTrunk):
def setUp(self):
super().setUp()
self.network.trunks = mock.Mock(return_value=self.new_trunks)
self.network_client.trunks = mock.Mock(return_value=self.new_trunks)
self.projects_mock.get.return_value = self.project
self.domains_mock.get.return_value = self.domain
@ -504,7 +508,7 @@ class TestListNetworkTrunk(TestNetworkTrunk):
columns, data = self.cmd.take_action(parsed_args)
self.network.trunks.assert_called_once_with()
self.network_client.trunks.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -519,7 +523,7 @@ class TestListNetworkTrunk(TestNetworkTrunk):
columns, data = self.cmd.take_action(parsed_args)
self.network.trunks.assert_called_once_with()
self.network_client.trunks.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertEqual(self.data_long, list(data))
@ -568,10 +572,12 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
def setUp(self):
super().setUp()
self.network.update_trunk = mock.Mock(return_value=self._trunk)
self.network.add_trunk_subports = mock.Mock(return_value=self._trunk)
self.network.find_trunk = mock.Mock(return_value=self._trunk)
self.network.find_port = mock.Mock(
self.network_client.update_trunk = mock.Mock(return_value=self._trunk)
self.network_client.add_trunk_subports = mock.Mock(
return_value=self._trunk
)
self.network_client.find_trunk = mock.Mock(return_value=self._trunk)
self.network_client.find_port = mock.Mock(
side_effect=[self.sub_port, self.sub_port]
)
@ -598,7 +604,9 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
attrs = {
attr: value,
}
self.network.update_trunk.assert_called_once_with(self._trunk, **attrs)
self.network_client.update_trunk.assert_called_once_with(
self._trunk, **attrs
)
self.assertIsNone(result)
def test_set_network_trunk_name(self):
@ -623,7 +631,9 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
attrs = {
'admin_state_up': False,
}
self.network.update_trunk.assert_called_once_with(self._trunk, **attrs)
self.network_client.update_trunk.assert_called_once_with(
self._trunk, **attrs
)
self.assertIsNone(result)
def test_set_network_trunk_admin_state_up_enable(self):
@ -642,7 +652,9 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
attrs = {
'admin_state_up': True,
}
self.network.update_trunk.assert_called_once_with(self._trunk, **attrs)
self.network_client.update_trunk.assert_called_once_with(
self._trunk, **attrs
)
self.assertIsNone(result)
def test_set_network_trunk_nothing(self):
@ -657,7 +669,9 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
result = self.cmd.take_action(parsed_args)
attrs = {}
self.network.update_trunk.assert_called_once_with(self._trunk, **attrs)
self.network_client.update_trunk.assert_called_once_with(
self._trunk, **attrs
)
self.assertIsNone(result)
def test_set_network_trunk_subports(self):
@ -690,7 +704,7 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.add_trunk_subports.assert_called_once_with(
self.network_client.add_trunk_subports.assert_called_once_with(
self._trunk, [subport]
)
self.assertIsNone(result)
@ -713,7 +727,7 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.add_trunk_subports.assert_called_once_with(
self.network_client.add_trunk_subports.assert_called_once_with(
self._trunk, [subport]
)
self.assertIsNone(result)
@ -746,7 +760,7 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
with testtools.ExpectedException(argparse.ArgumentTypeError):
self.check_parser(self.cmd, arglist, verifylist)
self.network.add_trunk_subports.assert_not_called()
self.network_client.add_trunk_subports.assert_not_called()
def test_set_trunk_attrs_with_exception(self):
arglist = [
@ -760,7 +774,7 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.network.update_trunk = mock.Mock(
self.network_client.update_trunk = mock.Mock(
side_effect=exceptions.CommandError
)
with testtools.ExpectedException(exceptions.CommandError) as e:
@ -769,8 +783,10 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
"Failed to set trunk '%s': " % self._trunk['name'], str(e)
)
attrs = {'name': 'reallylongname'}
self.network.update_trunk.assert_called_once_with(self._trunk, **attrs)
self.network.add_trunk_subports.assert_not_called()
self.network_client.update_trunk.assert_called_once_with(
self._trunk, **attrs
)
self.network_client.add_trunk_subports.assert_not_called()
def test_set_trunk_add_subport_with_exception(self):
arglist = [
@ -784,10 +800,10 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.network.add_trunk_subports = mock.Mock(
self.network_client.add_trunk_subports = mock.Mock(
side_effect=exceptions.CommandError
)
self.network.find_port = mock.Mock(
self.network_client.find_port = mock.Mock(
return_value={'id': 'invalid_subport'}
)
with testtools.ExpectedException(exceptions.CommandError) as e:
@ -796,8 +812,8 @@ class TestSetNetworkTrunk(TestNetworkTrunk):
"Failed to add subports to trunk '%s': " % self._trunk['name'],
str(e),
)
self.network.update_trunk.assert_called_once_with(self._trunk)
self.network.add_trunk_subports.assert_called_once_with(
self.network_client.update_trunk.assert_called_once_with(self._trunk)
self.network_client.add_trunk_subports.assert_called_once_with(
self._trunk, [{'port_id': 'invalid_subport'}]
)
@ -824,8 +840,8 @@ class TestListNetworkSubport(TestNetworkTrunk):
def setUp(self):
super().setUp()
self.network.find_trunk = mock.Mock(return_value=self._trunk)
self.network.get_trunk_subports = mock.Mock(
self.network_client.find_trunk = mock.Mock(return_value=self._trunk)
self.network_client.get_trunk_subports = mock.Mock(
return_value={network_trunk.SUB_PORTS: self._subports}
)
@ -843,7 +859,9 @@ class TestListNetworkSubport(TestNetworkTrunk):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.get_trunk_subports.assert_called_once_with(self._trunk)
self.network_client.get_trunk_subports.assert_called_once_with(
self._trunk
)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, list(data))
@ -892,11 +910,13 @@ class TestUnsetNetworkTrunk(TestNetworkTrunk):
def setUp(self):
super().setUp()
self.network.find_trunk = mock.Mock(return_value=self._trunk)
self.network.find_port = mock.Mock(
self.network_client.find_trunk = mock.Mock(return_value=self._trunk)
self.network_client.find_port = mock.Mock(
side_effect=[self.sub_port, self.sub_port]
)
self.network.delete_trunk_subports = mock.Mock(return_value=None)
self.network_client.delete_trunk_subports = mock.Mock(
return_value=None
)
# Get the command object to test
self.cmd = network_trunk.UnsetNetworkTrunk(self.app, self.namespace)
@ -918,7 +938,7 @@ class TestUnsetNetworkTrunk(TestNetworkTrunk):
result = self.cmd.take_action(parsed_args)
self.network.delete_trunk_subports.assert_called_once_with(
self.network_client.delete_trunk_subports.assert_called_once_with(
self._trunk, [{'port_id': subport['port_id']}]
)
self.assertIsNone(result)

360
openstackclient/tests/unit/network/v2/test_port.py

File diff suppressed because it is too large Load Diff

266
openstackclient/tests/unit/network/v2/test_router.py

@ -28,7 +28,7 @@ class TestRouter(network_fakes.TestNetworkV2):
super(TestRouter, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
self.projects_mock = self.app.client_manager.identity.projects
@ -42,10 +42,10 @@ class TestAddPortToRouter(TestRouter):
def setUp(self):
super(TestAddPortToRouter, self).setUp()
self.network.add_interface_to_router = mock.Mock()
self.network_client.add_interface_to_router = mock.Mock()
self.cmd = router.AddPortToRouter(self.app, self.namespace)
self.network.find_router = mock.Mock(return_value=self._router)
self.network.find_port = mock.Mock(return_value=self._port)
self.network_client.find_router = mock.Mock(return_value=self._router)
self.network_client.find_port = mock.Mock(return_value=self._port)
def test_add_port_no_option(self):
arglist = []
@ -72,7 +72,7 @@ class TestAddPortToRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.add_interface_to_router.assert_called_with(
self.network_client.add_interface_to_router.assert_called_with(
self._router,
**{
'port_id': self._router.port,
@ -91,10 +91,10 @@ class TestAddSubnetToRouter(TestRouter):
def setUp(self):
super(TestAddSubnetToRouter, self).setUp()
self.network.add_interface_to_router = mock.Mock()
self.network_client.add_interface_to_router = mock.Mock()
self.cmd = router.AddSubnetToRouter(self.app, self.namespace)
self.network.find_router = mock.Mock(return_value=self._router)
self.network.find_subnet = mock.Mock(return_value=self._subnet)
self.network_client.find_router = mock.Mock(return_value=self._router)
self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
def test_add_subnet_no_option(self):
arglist = []
@ -120,7 +120,7 @@ class TestAddSubnetToRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.add_interface_to_router.assert_called_with(
self.network_client.add_interface_to_router.assert_called_with(
self._router, **{'subnet_id': self._router.subnet}
)
@ -165,8 +165,10 @@ class TestCreateRouter(TestRouter):
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)
self.network_client.create_router = mock.Mock(
return_value=self.new_router
)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = router.CreateRouter(self.app, self.namespace)
@ -182,7 +184,7 @@ class TestCreateRouter(TestRouter):
arglist,
verifylist,
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
def test_create_default_options(self):
arglist = [
@ -198,21 +200,21 @@ class TestCreateRouter(TestRouter):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_router.assert_called_once_with(
self.network_client.create_router.assert_called_once_with(
**{
'admin_state_up': True,
'name': self.new_router.name,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
def test_create_with_gateway(self):
_network = network_fakes.create_one_network()
_subnet = network_fakes.FakeSubnet.create_one_subnet()
self.network.find_network = mock.Mock(return_value=_network)
self.network.find_subnet = mock.Mock(return_value=_subnet)
self.network_client.find_network = mock.Mock(return_value=_network)
self.network_client.find_subnet = mock.Mock(return_value=_subnet)
arglist = [
self.new_router.name,
'--external-gateway',
@ -234,7 +236,7 @@ class TestCreateRouter(TestRouter):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_router.assert_called_once_with(
self.network_client.create_router.assert_called_once_with(
**{
'admin_state_up': True,
'name': self.new_router.name,
@ -245,7 +247,7 @@ class TestCreateRouter(TestRouter):
},
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -265,7 +267,7 @@ class TestCreateRouter(TestRouter):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_router.assert_called_once_with(
self.network_client.create_router.assert_called_once_with(
**{
'admin_state_up': True,
'name': self.new_router.name,
@ -296,7 +298,7 @@ class TestCreateRouter(TestRouter):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_router.assert_called_once_with(
self.network_client.create_router.assert_called_once_with(
**{
'admin_state_up': True,
'name': self.new_router.name,
@ -330,7 +332,7 @@ class TestCreateRouter(TestRouter):
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(
self.network_client.create_router.assert_called_once_with(
**{
'admin_state_up': True,
'name': self.new_router.name,
@ -361,15 +363,15 @@ class TestCreateRouter(TestRouter):
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(
self.network_client.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.network_client.set_tags.assert_called_once_with(
self.new_router, tests_utils.CompareBySet(['red', 'blue'])
)
else:
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -395,7 +397,7 @@ class TestCreateRouter(TestRouter):
]
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(
self.network_client.create_router.assert_called_once_with(
**{
'admin_state_up': True,
'name': self.new_router.name,
@ -413,9 +415,9 @@ class TestDeleteRouter(TestRouter):
def setUp(self):
super(TestDeleteRouter, self).setUp()
self.network.delete_router = mock.Mock(return_value=None)
self.network_client.delete_router = mock.Mock(return_value=None)
self.network.find_router = network_fakes.FakeRouter.get_routers(
self.network_client.find_router = network_fakes.FakeRouter.get_routers(
self._routers
)
@ -432,7 +434,9 @@ class TestDeleteRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_router.assert_called_once_with(self._routers[0])
self.network_client.delete_router.assert_called_once_with(
self._routers[0]
)
self.assertIsNone(result)
def test_multi_routers_delete(self):
@ -451,7 +455,7 @@ class TestDeleteRouter(TestRouter):
calls = []
for r in self._routers:
calls.append(call(r))
self.network.delete_router.assert_has_calls(calls)
self.network_client.delete_router.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_routers_delete_with_exception(self):
@ -465,7 +469,9 @@ class TestDeleteRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._routers[0], exceptions.CommandError]
self.network.find_router = mock.Mock(side_effect=find_mock_result)
self.network_client.find_router = mock.Mock(
side_effect=find_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -473,13 +479,15 @@ class TestDeleteRouter(TestRouter):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 routers failed to delete.', str(e))
self.network.find_router.assert_any_call(
self.network_client.find_router.assert_any_call(
self._routers[0].name, ignore_missing=False
)
self.network.find_router.assert_any_call(
self.network_client.find_router.assert_any_call(
'unexist_router', ignore_missing=False
)
self.network.delete_router.assert_called_once_with(self._routers[0])
self.network_client.delete_router.assert_called_once_with(
self._routers[0]
)
class TestListRouter(TestRouter):
@ -568,15 +576,21 @@ class TestListRouter(TestRouter):
# Get the command object to test
self.cmd = router.ListRouter(self.app, self.namespace)
self.network.agent_hosted_routers = mock.Mock(
self.network_client.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.network_client.routers = mock.Mock(return_value=self.routers)
self.network_client.find_extension = mock.Mock(
return_value=self.extensions
)
self.network_client.find_router = mock.Mock(
return_value=self.routers[0]
)
self._testagent = network_fakes.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])
self.network_client.get_agent = mock.Mock(return_value=self._testagent)
self.network_client.get_router = mock.Mock(
return_value=self.routers[0]
)
def test_router_list_no_options(self):
arglist = []
@ -590,7 +604,7 @@ class TestListRouter(TestRouter):
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with()
self.network_client.routers.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -605,7 +619,9 @@ class TestListRouter(TestRouter):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
with mock.patch.object(self.network, "routers", return_value=_routers):
with mock.patch.object(
self.network_client, "routers", return_value=_routers
):
columns, data = self.cmd.take_action(parsed_args)
self.assertNotIn("is_distributed", columns)
@ -625,7 +641,7 @@ class TestListRouter(TestRouter):
# containing the data to be listed.
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with()
self.network_client.routers.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertCountEqual(self.data_long, list(data))
@ -639,14 +655,14 @@ class TestListRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# to mock, that no availability zone
self.network.find_extension = mock.Mock(return_value=None)
self.network_client.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.network_client.routers.assert_called_once_with()
self.assertEqual(self.columns_long_no_az, columns)
self.assertCountEqual(self.data_long_no_az, list(data))
@ -663,7 +679,9 @@ class TestListRouter(TestRouter):
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.network_client.routers.assert_called_once_with(
**{'name': test_name}
)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -678,7 +696,7 @@ class TestListRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with(
self.network_client.routers.assert_called_once_with(
**{'admin_state_up': True, 'is_admin_state_up': True}
)
self.assertEqual(self.columns, columns)
@ -692,7 +710,7 @@ class TestListRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with(
self.network_client.routers.assert_called_once_with(
**{'admin_state_up': False, 'is_admin_state_up': False}
)
@ -714,7 +732,7 @@ class TestListRouter(TestRouter):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.routers.assert_called_once_with(**filters)
self.network_client.routers.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -736,7 +754,7 @@ class TestListRouter(TestRouter):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.routers.assert_called_once_with(**filters)
self.network_client.routers.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -771,7 +789,7 @@ class TestListRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.agent_hosted_routers(*attrs)
self.network_client.agent_hosted_routers(*attrs)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -795,7 +813,7 @@ class TestListRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.routers.assert_called_once_with(
self.network_client.routers.assert_called_once_with(
**{
'tags': 'red,blue',
'any_tags': 'red,green',
@ -817,10 +835,10 @@ class TestRemovePortFromRouter(TestRouter):
def setUp(self):
super(TestRemovePortFromRouter, self).setUp()
self.network.remove_interface_from_router = mock.Mock()
self.network_client.remove_interface_from_router = mock.Mock()
self.cmd = router.RemovePortFromRouter(self.app, self.namespace)
self.network.find_router = mock.Mock(return_value=self._router)
self.network.find_port = mock.Mock(return_value=self._port)
self.network_client.find_router = mock.Mock(return_value=self._router)
self.network_client.find_port = mock.Mock(return_value=self._port)
def test_remove_port_no_option(self):
arglist = []
@ -847,7 +865,7 @@ class TestRemovePortFromRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.remove_interface_from_router.assert_called_with(
self.network_client.remove_interface_from_router.assert_called_with(
self._router, **{'port_id': self._router.port}
)
self.assertIsNone(result)
@ -863,10 +881,10 @@ class TestRemoveSubnetFromRouter(TestRouter):
def setUp(self):
super(TestRemoveSubnetFromRouter, self).setUp()
self.network.remove_interface_from_router = mock.Mock()
self.network_client.remove_interface_from_router = mock.Mock()
self.cmd = router.RemoveSubnetFromRouter(self.app, self.namespace)
self.network.find_router = mock.Mock(return_value=self._router)
self.network.find_subnet = mock.Mock(return_value=self._subnet)
self.network_client.find_router = mock.Mock(return_value=self._router)
self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
def test_remove_subnet_no_option(self):
arglist = []
@ -892,7 +910,7 @@ class TestRemoveSubnetFromRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.remove_interface_from_router.assert_called_with(
self.network_client.remove_interface_from_router.assert_called_with(
self._router, **{'subnet_id': self._router.subnet}
)
self.assertIsNone(result)
@ -903,11 +921,11 @@ class TestAddExtraRoutesToRouter(TestRouter):
def setUp(self):
super(TestAddExtraRoutesToRouter, self).setUp()
self.network.add_extra_routes_to_router = mock.Mock(
self.network_client.add_extra_routes_to_router = mock.Mock(
return_value=self._router
)
self.cmd = router.AddExtraRoutesToRouter(self.app, self.namespace)
self.network.find_router = mock.Mock(return_value=self._router)
self.network_client.find_router = mock.Mock(return_value=self._router)
def test_add_no_extra_route(self):
arglist = [
@ -920,7 +938,7 @@ class TestAddExtraRoutesToRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.add_extra_routes_to_router.assert_called_with(
self.network_client.add_extra_routes_to_router.assert_called_with(
self._router, body={'router': {'routes': []}}
)
self.assertEqual(2, len(result))
@ -939,7 +957,7 @@ class TestAddExtraRoutesToRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.add_extra_routes_to_router.assert_called_with(
self.network_client.add_extra_routes_to_router.assert_called_with(
self._router,
body={
'router': {
@ -973,7 +991,7 @@ class TestAddExtraRoutesToRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.add_extra_routes_to_router.assert_called_with(
self.network_client.add_extra_routes_to_router.assert_called_with(
self._router,
body={
'router': {
@ -992,11 +1010,11 @@ class TestRemoveExtraRoutesFromRouter(TestRouter):
def setUp(self):
super(TestRemoveExtraRoutesFromRouter, self).setUp()
self.network.remove_extra_routes_from_router = mock.Mock(
self.network_client.remove_extra_routes_from_router = mock.Mock(
return_value=self._router
)
self.cmd = router.RemoveExtraRoutesFromRouter(self.app, self.namespace)
self.network.find_router = mock.Mock(return_value=self._router)
self.network_client.find_router = mock.Mock(return_value=self._router)
def test_remove_no_extra_route(self):
arglist = [
@ -1009,7 +1027,7 @@ class TestRemoveExtraRoutesFromRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.remove_extra_routes_from_router.assert_called_with(
self.network_client.remove_extra_routes_from_router.assert_called_with(
self._router, body={'router': {'routes': []}}
)
self.assertEqual(2, len(result))
@ -1028,7 +1046,7 @@ class TestRemoveExtraRoutesFromRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.remove_extra_routes_from_router.assert_called_with(
self.network_client.remove_extra_routes_from_router.assert_called_with(
self._router,
body={
'router': {
@ -1062,7 +1080,7 @@ class TestRemoveExtraRoutesFromRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
self.network.remove_extra_routes_from_router.assert_called_with(
self.network_client.remove_extra_routes_from_router.assert_called_with(
self._router,
body={
'router': {
@ -1087,12 +1105,14 @@ class TestSetRouter(TestRouter):
def setUp(self):
super(TestSetRouter, self).setUp()
self.network.router_add_gateway = mock.Mock()
self.network.update_router = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network.find_router = mock.Mock(return_value=self._router)
self.network.find_network = mock.Mock(return_value=self._network)
self.network.find_subnet = mock.Mock(return_value=self._subnet)
self.network_client.router_add_gateway = mock.Mock()
self.network_client.update_router = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
self.network_client.find_router = mock.Mock(return_value=self._router)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
# Get the command object to test
self.cmd = router.SetRouter(self.app, self.namespace)
@ -1126,7 +1146,7 @@ class TestSetRouter(TestRouter):
'ha': False,
'description': 'router',
}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
self._router, **attrs
)
self.assertIsNone(result)
@ -1153,7 +1173,7 @@ class TestSetRouter(TestRouter):
'distributed': False,
'ha': True,
}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
self._router, **attrs
)
self.assertIsNone(result)
@ -1196,7 +1216,7 @@ class TestSetRouter(TestRouter):
result = self.cmd.take_action(parsed_args)
routes = [{'destination': '10.20.30.0/24', 'nexthop': '10.20.30.1'}]
attrs = {'routes': routes + self._router.routes}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
self._router, **attrs
)
self.assertIsNone(result)
@ -1217,7 +1237,7 @@ class TestSetRouter(TestRouter):
attrs = {
'routes': [],
}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
self._router, **attrs
)
self.assertIsNone(result)
@ -1226,7 +1246,7 @@ class TestSetRouter(TestRouter):
_testrouter = network_fakes.FakeRouter.create_one_router(
{'routes': [{"destination": "10.0.0.2", "nexthop": "1.1.1.1"}]}
)
self.network.find_router = mock.Mock(return_value=_testrouter)
self.network_client.find_router = mock.Mock(return_value=_testrouter)
arglist = [
_testrouter.name,
'--route',
@ -1248,7 +1268,7 @@ class TestSetRouter(TestRouter):
{'destination': '10.20.30.0/24', 'nexthop': '10.20.30.1'}
]
}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
_testrouter, **attrs
)
self.assertIsNone(result)
@ -1264,8 +1284,8 @@ class TestSetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_router.called)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.update_router.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertIsNone(result)
def test_wrong_gateway_params(self):
@ -1296,7 +1316,7 @@ class TestSetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_router.assert_called_with(
self.network_client.update_router.assert_called_with(
self._router,
**{'external_gateway_info': {'network_id': self._network.id}}
)
@ -1320,7 +1340,7 @@ class TestSetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_router.assert_called_with(
self.network_client.update_router.assert_called_with(
self._router,
**{
'external_gateway_info': {
@ -1354,7 +1374,7 @@ class TestSetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_router.assert_called_with(
self.network_client.update_router.assert_called_with(
self._router,
**{
'external_gateway_info': {
@ -1388,7 +1408,7 @@ class TestSetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_router.assert_called_with(
self.network_client.update_router.assert_called_with(
self._router,
**{
'external_gateway_info': {
@ -1420,8 +1440,8 @@ class TestSetRouter(TestRouter):
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.assertFalse(self.network_client.update_router.called)
self.network_client.set_tags.assert_called_once_with(
self._router, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)
@ -1434,7 +1454,9 @@ class TestSetRouter(TestRouter):
def test_set_gateway_ip_qos(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
arglist = [
"--external-gateway",
self._network.id,
@ -1450,7 +1472,7 @@ class TestSetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_router.assert_called_with(
self.network_client.update_router.assert_called_with(
self._router,
**{
'external_gateway_info': {
@ -1476,7 +1498,7 @@ class TestSetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_router.assert_called_with(
self.network_client.update_router.assert_called_with(
self._router,
**{
'external_gateway_info': {
@ -1489,7 +1511,9 @@ class TestSetRouter(TestRouter):
def test_set_unset_gateway_ip_qos(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
arglist = [
"--external-gateway",
self._network.id,
@ -1515,9 +1539,11 @@ class TestSetRouter(TestRouter):
def test_set_gateway_ip_qos_no_gateway(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
router = network_fakes.FakeRouter.create_one_router()
self.network.find_router = mock.Mock(return_value=router)
self.network_client.find_router = mock.Mock(return_value=router)
arglist = [
"--qos-policy",
qos_policy.id,
@ -1535,9 +1561,11 @@ class TestSetRouter(TestRouter):
def test_unset_gateway_ip_qos_no_gateway(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
router = network_fakes.FakeRouter.create_one_router()
self.network.find_router = mock.Mock(return_value=router)
self.network_client.find_router = mock.Mock(return_value=router)
arglist = [
"--no-qos-policy",
router.id,
@ -1606,8 +1634,8 @@ class TestShowRouter(TestRouter):
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])
self.network_client.find_router = mock.Mock(return_value=self._router)
self.network_client.ports = mock.Mock(return_value=[self._port])
# Get the command object to test
self.cmd = router.ShowRouter(self.app, self.namespace)
@ -1635,10 +1663,12 @@ class TestShowRouter(TestRouter):
columns, data = self.cmd.take_action(parsed_args)
self.network.find_router.assert_called_once_with(
self.network_client.find_router.assert_called_once_with(
self._router.name, ignore_missing=False
)
self.network.ports.assert_called_with(**{'device_id': self._router.id})
self.network_client.ports.assert_called_with(
**{'device_id': self._router.id}
)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -1656,7 +1686,7 @@ class TestShowRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
with mock.patch.object(
self.network, "find_router", return_value=_router
self.network_client, "find_router", return_value=_router
):
columns, data = self.cmd.take_action(parsed_args)
@ -1675,7 +1705,7 @@ class TestShowRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
with mock.patch.object(
self.network, "find_router", return_value=_router
self.network_client, "find_router", return_value=_router
):
columns, data = self.cmd.take_action(parsed_args)
@ -1710,9 +1740,11 @@ class TestUnsetRouter(TestRouter):
}
)
self.fake_subnet = network_fakes.FakeSubnet.create_one_subnet()
self.network.find_router = mock.Mock(return_value=self._testrouter)
self.network.update_router = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.find_router = mock.Mock(
return_value=self._testrouter
)
self.network_client.update_router = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = router.UnsetRouter(self.app, self.namespace)
@ -1737,7 +1769,7 @@ class TestUnsetRouter(TestRouter):
{"destination": "192.168.101.2/24", "nexthop": "172.24.4.3"}
],
}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
self._testrouter, **attrs
)
self.assertIsNone(result)
@ -1769,7 +1801,7 @@ class TestUnsetRouter(TestRouter):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {'external_gateway_info': {}}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
self._testrouter, **attrs
)
self.assertIsNone(result)
@ -1789,8 +1821,8 @@ class TestUnsetRouter(TestRouter):
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.assertFalse(self.network_client.update_router.called)
self.network_client.set_tags.assert_called_once_with(
self._testrouter, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)
@ -1815,16 +1847,18 @@ class TestUnsetRouter(TestRouter):
"qos_policy_id": None,
}
}
self.network.update_router.assert_called_once_with(
self.network_client.update_router.assert_called_once_with(
self._testrouter, **attrs
)
self.assertIsNone(result)
def test_unset_gateway_ip_qos_no_network(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
router = network_fakes.FakeRouter.create_one_router()
self.network.find_router = mock.Mock(return_value=router)
self.network_client.find_router = mock.Mock(return_value=router)
arglist = [
"--qos-policy",
router.id,
@ -1840,11 +1874,13 @@ class TestUnsetRouter(TestRouter):
def test_unset_gateway_ip_qos_no_qos(self):
qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
self.network.find_qos_policy = mock.Mock(return_value=qos_policy)
self.network_client.find_qos_policy = mock.Mock(
return_value=qos_policy
)
router = network_fakes.FakeRouter.create_one_router(
{"external_gateway_info": {"network_id": "fake-id"}}
)
self.network.find_router = mock.Mock(return_value=router)
self.network_client.find_router = mock.Mock(return_value=router)
arglist = [
"--qos-policy",
router.id,

82
openstackclient/tests/unit/network/v2/test_security_group_network.py

@ -27,7 +27,7 @@ class TestSecurityGroupNetwork(network_fakes.TestNetworkV2):
super(TestSecurityGroupNetwork, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -65,13 +65,13 @@ class TestCreateSecurityGroupNetwork(TestSecurityGroupNetwork):
def setUp(self):
super(TestCreateSecurityGroupNetwork, self).setUp()
self.network.create_security_group = mock.Mock(
self.network_client.create_security_group = mock.Mock(
return_value=self._security_group
)
self.projects_mock.get.return_value = self.project
self.domains_mock.get.return_value = self.domain
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = security_group.CreateSecurityGroup(self.app, self.namespace)
@ -92,7 +92,7 @@ class TestCreateSecurityGroupNetwork(TestSecurityGroupNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group.assert_called_once_with(
self.network_client.create_security_group.assert_called_once_with(
**{
'description': self._security_group.name,
'name': self._security_group.name,
@ -123,7 +123,7 @@ class TestCreateSecurityGroupNetwork(TestSecurityGroupNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group.assert_called_once_with(
self.network_client.create_security_group.assert_called_once_with(
**{
'description': self._security_group.description,
'stateful': self._security_group.stateful,
@ -152,18 +152,18 @@ class TestCreateSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group.assert_called_once_with(
self.network_client.create_security_group.assert_called_once_with(
**{
'description': self._security_group.name,
'name': self._security_group.name,
}
)
if add_tags:
self.network.set_tags.assert_called_once_with(
self.network_client.set_tags.assert_called_once_with(
self._security_group, tests_utils.CompareBySet(['red', 'blue'])
)
else:
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -181,9 +181,11 @@ class TestDeleteSecurityGroupNetwork(TestSecurityGroupNetwork):
def setUp(self):
super(TestDeleteSecurityGroupNetwork, self).setUp()
self.network.delete_security_group = mock.Mock(return_value=None)
self.network_client.delete_security_group = mock.Mock(
return_value=None
)
self.network.find_security_group = (
self.network_client.find_security_group = (
network_fakes.FakeSecurityGroup.get_security_groups(
self._security_groups
)
@ -203,7 +205,7 @@ class TestDeleteSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_security_group.assert_called_once_with(
self.network_client.delete_security_group.assert_called_once_with(
self._security_groups[0]
)
self.assertIsNone(result)
@ -224,7 +226,7 @@ class TestDeleteSecurityGroupNetwork(TestSecurityGroupNetwork):
calls = []
for s in self._security_groups:
calls.append(call(s))
self.network.delete_security_group.assert_has_calls(calls)
self.network_client.delete_security_group.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_security_groups_delete_with_exception(self):
@ -241,7 +243,7 @@ class TestDeleteSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._security_groups[0], exceptions.CommandError]
self.network.find_security_group = mock.Mock(
self.network_client.find_security_group = mock.Mock(
side_effect=find_mock_result
)
@ -251,13 +253,13 @@ class TestDeleteSecurityGroupNetwork(TestSecurityGroupNetwork):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 groups failed to delete.', str(e))
self.network.find_security_group.assert_any_call(
self.network_client.find_security_group.assert_any_call(
self._security_groups[0].name, ignore_missing=False
)
self.network.find_security_group.assert_any_call(
self.network_client.find_security_group.assert_any_call(
'unexist_security_group', ignore_missing=False
)
self.network.delete_security_group.assert_called_once_with(
self.network_client.delete_security_group.assert_called_once_with(
self._security_groups[0]
)
@ -291,7 +293,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork):
def setUp(self):
super(TestListSecurityGroupNetwork, self).setUp()
self.network.security_groups = mock.Mock(
self.network_client.security_groups = mock.Mock(
return_value=self._security_groups
)
@ -307,7 +309,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_groups.assert_called_once_with(
self.network_client.security_groups.assert_called_once_with(
fields=security_group.ListSecurityGroup.FIELDS_TO_RETRIEVE
)
self.assertEqual(self.columns, columns)
@ -324,7 +326,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_groups.assert_called_once_with(
self.network_client.security_groups.assert_called_once_with(
fields=security_group.ListSecurityGroup.FIELDS_TO_RETRIEVE
)
self.assertEqual(self.columns, columns)
@ -348,7 +350,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork):
'fields': security_group.ListSecurityGroup.FIELDS_TO_RETRIEVE,
}
self.network.security_groups.assert_called_once_with(**filters)
self.network_client.security_groups.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -373,7 +375,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork):
'fields': security_group.ListSecurityGroup.FIELDS_TO_RETRIEVE,
}
self.network.security_groups.assert_called_once_with(**filters)
self.network_client.security_groups.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -397,7 +399,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.security_groups.assert_called_once_with(
self.network_client.security_groups.assert_called_once_with(
**{
'tags': 'red,blue',
'any_tags': 'red,green',
@ -421,12 +423,14 @@ class TestSetSecurityGroupNetwork(TestSecurityGroupNetwork):
def setUp(self):
super(TestSetSecurityGroupNetwork, self).setUp()
self.network.update_security_group = mock.Mock(return_value=None)
self.network_client.update_security_group = mock.Mock(
return_value=None
)
self.network.find_security_group = mock.Mock(
self.network_client.find_security_group = mock.Mock(
return_value=self._security_group
)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = security_group.SetSecurityGroup(self.app, self.namespace)
@ -447,7 +451,7 @@ class TestSetSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_security_group.assert_called_once_with(
self.network_client.update_security_group.assert_called_once_with(
self._security_group, **{}
)
self.assertIsNone(result)
@ -478,7 +482,7 @@ class TestSetSecurityGroupNetwork(TestSecurityGroupNetwork):
'name': new_name,
'stateful': True,
}
self.network.update_security_group.assert_called_once_with(
self.network_client.update_security_group.assert_called_once_with(
self._security_group, **attrs
)
self.assertIsNone(result)
@ -498,8 +502,8 @@ class TestSetSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertTrue(self.network.update_security_group.called)
self.network.set_tags.assert_called_once_with(
self.assertTrue(self.network_client.update_security_group.called)
self.network_client.set_tags.assert_called_once_with(
self._security_group, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)
@ -549,7 +553,7 @@ class TestShowSecurityGroupNetwork(TestSecurityGroupNetwork):
def setUp(self):
super(TestShowSecurityGroupNetwork, self).setUp()
self.network.find_security_group = mock.Mock(
self.network_client.find_security_group = mock.Mock(
return_value=self._security_group
)
@ -572,7 +576,7 @@ class TestShowSecurityGroupNetwork(TestSecurityGroupNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.find_security_group.assert_called_once_with(
self.network_client.find_security_group.assert_called_once_with(
self._security_group.id, ignore_missing=False
)
self.assertEqual(self.columns, columns)
@ -590,12 +594,14 @@ class TestUnsetSecurityGroupNetwork(TestSecurityGroupNetwork):
def setUp(self):
super(TestUnsetSecurityGroupNetwork, self).setUp()
self.network.update_security_group = mock.Mock(return_value=None)
self.network_client.update_security_group = mock.Mock(
return_value=None
)
self.network.find_security_group = mock.Mock(
self.network_client.find_security_group = mock.Mock(
return_value=self._security_group
)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = security_group.UnsetSecurityGroup(self.app, self.namespace)
@ -616,8 +622,8 @@ class TestUnsetSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_security_group.called)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.update_security_group.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertIsNone(result)
def _test_unset_tags(self, with_tags=True):
@ -635,8 +641,8 @@ class TestUnsetSecurityGroupNetwork(TestSecurityGroupNetwork):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_security_group.called)
self.network.set_tags.assert_called_once_with(
self.assertFalse(self.network_client.update_security_group.called)
self.network_client.set_tags.assert_called_once_with(
self._security_group, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)

78
openstackclient/tests/unit/network/v2/test_security_group_rule_network.py

@ -27,7 +27,7 @@ class TestSecurityGroupRuleNetwork(network_fakes.TestNetworkV2):
super(TestSecurityGroupRuleNetwork, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -71,7 +71,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
attrs
)
)
self.network.create_security_group_rule = mock.Mock(
self.network_client.create_security_group_rule = mock.Mock(
return_value=self._security_group_rule
)
self.expected_data = (
@ -92,11 +92,11 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
def setUp(self):
super(TestCreateSecurityGroupRuleNetwork, self).setUp()
self.network.find_security_group = mock.Mock(
self.network_client.find_security_group = mock.Mock(
return_value=self._security_group
)
self.network.find_address_group = mock.Mock(
self.network_client.find_address_group = mock.Mock(
return_value=self._address_group
)
@ -238,7 +238,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -276,7 +276,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -312,7 +312,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -346,7 +346,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -392,7 +392,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -427,7 +427,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -462,7 +462,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -497,7 +497,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -554,7 +554,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -718,7 +718,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -757,7 +757,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -796,7 +796,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -835,7 +835,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -877,7 +877,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -918,7 +918,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'direction': self._security_group_rule.direction,
'ethertype': self._security_group_rule.ether_type,
@ -950,7 +950,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_security_group_rule.assert_called_once_with(
self.network_client.create_security_group_rule.assert_called_once_with(
**{
'description': self._security_group_rule.description,
'direction': self._security_group_rule.direction,
@ -975,9 +975,11 @@ class TestDeleteSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
def setUp(self):
super(TestDeleteSecurityGroupRuleNetwork, self).setUp()
self.network.delete_security_group_rule = mock.Mock(return_value=None)
self.network_client.delete_security_group_rule = mock.Mock(
return_value=None
)
self.network.find_security_group_rule = (
self.network_client.find_security_group_rule = (
network_fakes.FakeSecurityGroupRule.get_security_group_rules(
self._security_group_rules
)
@ -999,7 +1001,7 @@ class TestDeleteSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
result = self.cmd.take_action(parsed_args)
self.network.delete_security_group_rule.assert_called_once_with(
self.network_client.delete_security_group_rule.assert_called_once_with(
self._security_group_rules[0]
)
self.assertIsNone(result)
@ -1020,7 +1022,7 @@ class TestDeleteSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
calls = []
for s in self._security_group_rules:
calls.append(call(s))
self.network.delete_security_group_rule.assert_has_calls(calls)
self.network_client.delete_security_group_rule.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_security_group_rules_delete_with_exception(self):
@ -1037,7 +1039,7 @@ class TestDeleteSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
self._security_group_rules[0],
exceptions.CommandError,
]
self.network.find_security_group_rule = mock.Mock(
self.network_client.find_security_group_rule = mock.Mock(
side_effect=find_mock_result
)
@ -1047,13 +1049,13 @@ class TestDeleteSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 rules failed to delete.', str(e))
self.network.find_security_group_rule.assert_any_call(
self.network_client.find_security_group_rule.assert_any_call(
self._security_group_rules[0].id, ignore_missing=False
)
self.network.find_security_group_rule.assert_any_call(
self.network_client.find_security_group_rule.assert_any_call(
'unexist_rule', ignore_missing=False
)
self.network.delete_security_group_rule.assert_called_once_with(
self.network_client.delete_security_group_rule.assert_called_once_with(
self._security_group_rules[0]
)
@ -1151,10 +1153,10 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
def setUp(self):
super(TestListSecurityGroupRuleNetwork, self).setUp()
self.network.find_security_group = mock.Mock(
self.network_client.find_security_group = mock.Mock(
return_value=self._security_group
)
self.network.security_group_rules = mock.Mock(
self.network_client.security_group_rules = mock.Mock(
return_value=self._security_group_rules
)
@ -1169,7 +1171,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_group_rules.assert_called_once_with(**{})
self.network_client.security_group_rules.assert_called_once_with(**{})
self.assertEqual(self.expected_columns_no_group, columns)
self.assertEqual(self.expected_data_no_group, list(data))
@ -1185,7 +1187,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_group_rules.assert_called_once_with(
self.network_client.security_group_rules.assert_called_once_with(
**{
'security_group_id': self._security_group.id,
}
@ -1205,7 +1207,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_group_rules.assert_called_once_with(**{})
self.network_client.security_group_rules.assert_called_once_with(**{})
self.assertEqual(self.expected_columns_no_group, columns)
self.assertEqual(self.expected_data_no_group, list(data))
@ -1222,7 +1224,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_group_rules.assert_called_once_with(
self.network_client.security_group_rules.assert_called_once_with(
**{
'protocol': 'tcp',
}
@ -1242,7 +1244,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_group_rules.assert_called_once_with(
self.network_client.security_group_rules.assert_called_once_with(
**{
'direction': 'ingress',
}
@ -1262,7 +1264,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.security_group_rules.assert_called_once_with(
self.network_client.security_group_rules.assert_called_once_with(
**{
'direction': 'egress',
}
@ -1310,7 +1312,7 @@ class TestShowSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
def setUp(self):
super(TestShowSecurityGroupRuleNetwork, self).setUp()
self.network.find_security_group_rule = mock.Mock(
self.network_client.find_security_group_rule = mock.Mock(
return_value=self._security_group_rule
)
@ -1335,7 +1337,7 @@ class TestShowSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
columns, data = self.cmd.take_action(parsed_args)
self.network.find_security_group_rule.assert_called_once_with(
self.network_client.find_security_group_rule.assert_called_once_with(
self._security_group_rule.id, ignore_missing=False
)
self.assertEqual(self.columns, columns)

194
openstackclient/tests/unit/network/v2/test_subnet.py

@ -28,7 +28,7 @@ class TestSubnet(network_fakes.TestNetworkV2):
super(TestSubnet, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -223,13 +223,17 @@ class TestCreateSubnet(TestSubnet):
self.domains_mock.get.return_value = self.domain
# Mock SDK calls for all tests.
self.network.create_subnet = mock.Mock(return_value=self._subnet)
self.network.set_tags = mock.Mock(return_value=None)
self.network.find_network = mock.Mock(return_value=self._network)
self.network.find_segment = mock.Mock(
self.network_client.create_subnet = mock.Mock(
return_value=self._subnet
)
self.network_client.set_tags = mock.Mock(return_value=None)
self.network_client.find_network = mock.Mock(
return_value=self._network
)
self.network_client.find_segment = mock.Mock(
return_value=self._network_segment
)
self.network.find_subnet_pool = mock.Mock(
self.network_client.find_subnet_pool = mock.Mock(
return_value=self._subnet_pool
)
@ -246,8 +250,8 @@ class TestCreateSubnet(TestSubnet):
arglist,
verifylist,
)
self.assertFalse(self.network.create_subnet.called)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.create_subnet.called)
self.assertFalse(self.network_client.set_tags.called)
def test_create_default_options(self):
# Mock SDK calls for this test.
@ -271,7 +275,7 @@ class TestCreateSubnet(TestSubnet):
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(
self.network_client.create_subnet.assert_called_once_with(
**{
'cidr': self._subnet.cidr,
'ip_version': self._subnet.ip_version,
@ -279,14 +283,14 @@ class TestCreateSubnet(TestSubnet):
'network_id': self._subnet.network_id,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
def test_create_from_subnet_pool_options(self):
# Mock SDK calls for this test.
self.network.create_subnet.return_value = self._subnet_from_pool
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.create_subnet.return_value = self._subnet_from_pool
self.network_client.set_tags = mock.Mock(return_value=None)
self._network.id = self._subnet_from_pool.network_id
arglist = [
@ -343,7 +347,7 @@ class TestCreateSubnet(TestSubnet):
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(
self.network_client.create_subnet.assert_called_once_with(
**{
'dns_nameservers': self._subnet_from_pool.dns_nameservers,
'enable_dhcp': self._subnet_from_pool.enable_dhcp,
@ -362,7 +366,7 @@ class TestCreateSubnet(TestSubnet):
def test_create_options_subnet_range_ipv6(self):
# Mock SDK calls for this test.
self.network.create_subnet.return_value = self._subnet_ipv6
self.network_client.create_subnet.return_value = self._subnet_ipv6
self._network.id = self._subnet_ipv6.network_id
arglist = [
@ -433,7 +437,7 @@ class TestCreateSubnet(TestSubnet):
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(
self.network_client.create_subnet.assert_called_once_with(
**{
'cidr': self._subnet_ipv6.cidr,
'dns_nameservers': self._subnet_ipv6.dns_nameservers,
@ -449,7 +453,7 @@ class TestCreateSubnet(TestSubnet):
'service_types': self._subnet_ipv6.service_types,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data_ipv6, data)
@ -478,7 +482,7 @@ class TestCreateSubnet(TestSubnet):
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(
self.network_client.create_subnet.assert_called_once_with(
**{
'cidr': self._subnet.cidr,
'ip_version': self._subnet.ip_version,
@ -487,7 +491,7 @@ class TestCreateSubnet(TestSubnet):
'segment_id': self._network_segment.id,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -516,7 +520,7 @@ class TestCreateSubnet(TestSubnet):
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(
self.network_client.create_subnet.assert_called_once_with(
**{
'cidr': self._subnet.cidr,
'ip_version': self._subnet.ip_version,
@ -525,7 +529,7 @@ class TestCreateSubnet(TestSubnet):
'description': self._subnet.description,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -553,7 +557,7 @@ class TestCreateSubnet(TestSubnet):
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(
self.network_client.create_subnet.assert_called_once_with(
cidr=self._subnet.cidr,
ip_version=self._subnet.ip_version,
name=self._subnet.name,
@ -596,18 +600,18 @@ class TestCreateSubnet(TestSubnet):
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(
self.network_client.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.network_client.set_tags.assert_called_once_with(
self._subnet, tests_utils.CompareBySet(['red', 'blue'])
)
else:
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -625,9 +629,9 @@ class TestDeleteSubnet(TestSubnet):
def setUp(self):
super(TestDeleteSubnet, self).setUp()
self.network.delete_subnet = mock.Mock(return_value=None)
self.network_client.delete_subnet = mock.Mock(return_value=None)
self.network.find_subnet = network_fakes.FakeSubnet.get_subnets(
self.network_client.find_subnet = network_fakes.FakeSubnet.get_subnets(
self._subnets
)
@ -644,7 +648,9 @@ class TestDeleteSubnet(TestSubnet):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.delete_subnet.assert_called_once_with(self._subnets[0])
self.network_client.delete_subnet.assert_called_once_with(
self._subnets[0]
)
self.assertIsNone(result)
def test_multi_subnets_delete(self):
@ -663,7 +669,7 @@ class TestDeleteSubnet(TestSubnet):
calls = []
for s in self._subnets:
calls.append(call(s))
self.network.delete_subnet.assert_has_calls(calls)
self.network_client.delete_subnet.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_subnets_delete_with_exception(self):
@ -677,7 +683,9 @@ class TestDeleteSubnet(TestSubnet):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._subnets[0], exceptions.CommandError]
self.network.find_subnet = mock.Mock(side_effect=find_mock_result)
self.network_client.find_subnet = mock.Mock(
side_effect=find_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -685,13 +693,15 @@ class TestDeleteSubnet(TestSubnet):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 subnets failed to delete.', str(e))
self.network.find_subnet.assert_any_call(
self.network_client.find_subnet.assert_any_call(
self._subnets[0].name, ignore_missing=False
)
self.network.find_subnet.assert_any_call(
self.network_client.find_subnet.assert_any_call(
'unexist_subnet', ignore_missing=False
)
self.network.delete_subnet.assert_called_once_with(self._subnets[0])
self.network_client.delete_subnet.assert_called_once_with(
self._subnets[0]
)
class TestListSubnet(TestSubnet):
@ -753,7 +763,7 @@ class TestListSubnet(TestSubnet):
# Get the command object to test
self.cmd = subnet_v2.ListSubnet(self.app, self.namespace)
self.network.subnets = mock.Mock(return_value=self._subnet)
self.network_client.subnets = mock.Mock(return_value=self._subnet)
def test_subnet_list_no_options(self):
arglist = []
@ -764,7 +774,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
self.network.subnets.assert_called_once_with()
self.network_client.subnets.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -779,7 +789,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
self.network.subnets.assert_called_once_with()
self.network_client.subnets.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertCountEqual(self.data_long, list(data))
@ -796,7 +806,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'ip_version': 4}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -812,7 +822,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'enable_dhcp': True, 'is_dhcp_enabled': True}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -828,7 +838,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'enable_dhcp': False, 'is_dhcp_enabled': False}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -844,7 +854,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'service_types': ['network:router_gateway']}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -863,7 +873,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -889,7 +899,7 @@ class TestListSubnet(TestSubnet):
'network:floatingip_agent_gateway',
]
}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -911,13 +921,13 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
def test_subnet_list_network(self):
network = network_fakes.create_one_network()
self.network.find_network = mock.Mock(return_value=network)
self.network_client.find_network = mock.Mock(return_value=network)
arglist = [
'--network',
network.id,
@ -930,13 +940,13 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'network_id': network.id}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
def test_subnet_list_gateway(self):
subnet = network_fakes.FakeSubnet.create_one_subnet()
self.network.find_network = mock.Mock(return_value=subnet)
self.network_client.find_network = mock.Mock(return_value=subnet)
arglist = [
'--gateway',
subnet.gateway_ip,
@ -949,13 +959,13 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'gateway_ip': subnet.gateway_ip}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
def test_subnet_list_name(self):
subnet = network_fakes.FakeSubnet.create_one_subnet()
self.network.find_network = mock.Mock(return_value=subnet)
self.network_client.find_network = mock.Mock(return_value=subnet)
arglist = [
'--name',
subnet.name,
@ -968,13 +978,13 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'name': subnet.name}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
def test_subnet_list_subnet_range(self):
subnet = network_fakes.FakeSubnet.create_one_subnet()
self.network.find_network = mock.Mock(return_value=subnet)
self.network_client.find_network = mock.Mock(return_value=subnet)
arglist = [
'--subnet-range',
subnet.cidr,
@ -987,7 +997,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'cidr': subnet.cidr}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -996,8 +1006,10 @@ class TestListSubnet(TestSubnet):
subnet = network_fakes.FakeSubnet.create_one_subnet(
{'subnetpool_id': subnet_pool.id}
)
self.network.find_network = mock.Mock(return_value=subnet)
self.network.find_subnet_pool = mock.Mock(return_value=subnet_pool)
self.network_client.find_network = mock.Mock(return_value=subnet)
self.network_client.find_subnet_pool = mock.Mock(
return_value=subnet_pool
)
arglist = [
'--subnet-pool',
subnet_pool.name,
@ -1010,7 +1022,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'subnetpool_id': subnet_pool.id}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -1019,8 +1031,10 @@ class TestListSubnet(TestSubnet):
subnet = network_fakes.FakeSubnet.create_one_subnet(
{'subnetpool_id': subnet_pool.id}
)
self.network.find_network = mock.Mock(return_value=subnet)
self.network.find_subnet_pool = mock.Mock(return_value=subnet_pool)
self.network_client.find_network = mock.Mock(return_value=subnet)
self.network_client.find_subnet_pool = mock.Mock(
return_value=subnet_pool
)
arglist = [
'--subnet-pool',
subnet_pool.id,
@ -1033,7 +1047,7 @@ class TestListSubnet(TestSubnet):
columns, data = self.cmd.take_action(parsed_args)
filters = {'subnetpool_id': subnet_pool.id}
self.network.subnets.assert_called_once_with(**filters)
self.network_client.subnets.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -1057,7 +1071,7 @@ class TestListSubnet(TestSubnet):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.subnets.assert_called_once_with(
self.network_client.subnets.assert_called_once_with(
**{
'tags': 'red,blue',
'any_tags': 'red,green',
@ -1076,9 +1090,9 @@ class TestSetSubnet(TestSubnet):
def setUp(self):
super(TestSetSubnet, self).setUp()
self.network.update_subnet = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network.find_subnet = mock.Mock(return_value=self._subnet)
self.network_client.update_subnet = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
self.cmd = subnet_v2.SetSubnet(self.app, self.namespace)
def test_set_this(self):
@ -1104,7 +1118,9 @@ class TestSetSubnet(TestSubnet):
'gateway_ip': self._subnet.gateway_ip,
'name': "new_subnet",
}
self.network.update_subnet.assert_called_with(self._subnet, **attrs)
self.network_client.update_subnet.assert_called_with(
self._subnet, **attrs
)
self.assertIsNone(result)
def test_set_that(self):
@ -1130,7 +1146,9 @@ class TestSetSubnet(TestSubnet):
'gateway_ip': None,
'name': "new_subnet",
}
self.network.update_subnet.assert_called_with(self._subnet, **attrs)
self.network_client.update_subnet.assert_called_with(
self._subnet, **attrs
)
self.assertIsNone(result)
def test_set_nothing(self):
@ -1142,8 +1160,8 @@ class TestSetSubnet(TestSubnet):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.assertFalse(self.network.update_subnet.called)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.update_subnet.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertIsNone(result)
def test_append_options(self):
@ -1153,7 +1171,7 @@ class TestSetSubnet(TestSubnet):
'service_types': ["network:router_gateway"],
}
)
self.network.find_subnet = mock.Mock(return_value=_testsubnet)
self.network_client.find_subnet = mock.Mock(return_value=_testsubnet)
arglist = [
'--dns-nameserver',
'10.0.0.2',
@ -1174,7 +1192,7 @@ class TestSetSubnet(TestSubnet):
'network:router_gateway',
],
}
self.network.update_subnet.assert_called_once_with(
self.network_client.update_subnet.assert_called_once_with(
_testsubnet, **attrs
)
self.assertIsNone(result)
@ -1202,7 +1220,9 @@ class TestSetSubnet(TestSubnet):
'gateway_ip': self._subnet.gateway_ip,
'description': "new_description",
}
self.network.update_subnet.assert_called_with(self._subnet, **attrs)
self.network_client.update_subnet.assert_called_with(
self._subnet, **attrs
)
self.assertIsNone(result)
def test_overwrite_options(self):
@ -1217,7 +1237,7 @@ class TestSetSubnet(TestSubnet):
'dns_nameservers': ["10.0.0.1"],
}
)
self.network.find_subnet = mock.Mock(return_value=_testsubnet)
self.network_client.find_subnet = mock.Mock(return_value=_testsubnet)
arglist = [
'--host-route',
'destination=10.30.30.30/24,gateway=10.30.30.1',
@ -1250,7 +1270,7 @@ class TestSetSubnet(TestSubnet):
'allocation_pools': [{'start': '8.8.8.100', 'end': '8.8.8.150'}],
'dns_nameservers': ["10.1.10.1"],
}
self.network.update_subnet.assert_called_once_with(
self.network_client.update_subnet.assert_called_once_with(
_testsubnet, **attrs
)
self.assertIsNone(result)
@ -1267,7 +1287,7 @@ class TestSetSubnet(TestSubnet):
'dns_nameservers': ['10.0.0.1'],
}
)
self.network.find_subnet = mock.Mock(return_value=_testsubnet)
self.network_client.find_subnet = mock.Mock(return_value=_testsubnet)
arglist = [
'--no-host-route',
'--no-allocation-pool',
@ -1286,7 +1306,7 @@ class TestSetSubnet(TestSubnet):
'allocation_pools': [],
'dns_nameservers': [],
}
self.network.update_subnet.assert_called_once_with(
self.network_client.update_subnet.assert_called_once_with(
_testsubnet, **attrs
)
self.assertIsNone(result)
@ -1306,8 +1326,8 @@ class TestSetSubnet(TestSubnet):
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.assertFalse(self.network_client.update_subnet.called)
self.network_client.set_tags.assert_called_once_with(
self._subnet, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)
@ -1336,15 +1356,17 @@ class TestSetSubnet(TestSubnet):
'segment_id': None,
}
)
self.network.find_subnet = mock.Mock(return_value=_subnet)
self.network.find_segment = mock.Mock(return_value=_segment)
self.network_client.find_subnet = mock.Mock(return_value=_subnet)
self.network_client.find_segment = mock.Mock(return_value=_segment)
arglist = ['--network-segment', _segment.id, _subnet.name]
verifylist = [('network_segment', _segment.id)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
attrs = {'segment_id': _segment.id}
self.network.update_subnet.assert_called_once_with(_subnet, **attrs)
self.network.update_subnet.assert_called_with(_subnet, **attrs)
self.network_client.update_subnet.assert_called_once_with(
_subnet, **attrs
)
self.network_client.update_subnet.assert_called_with(_subnet, **attrs)
self.assertIsNone(result)
@ -1400,7 +1422,7 @@ class TestShowSubnet(TestSubnet):
# Get the command object to test
self.cmd = subnet_v2.ShowSubnet(self.app, self.namespace)
self.network.find_subnet = mock.Mock(return_value=self._subnet)
self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
def test_show_no_options(self):
arglist = []
@ -1427,7 +1449,7 @@ class TestShowSubnet(TestSubnet):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.find_subnet.assert_called_once_with(
self.network_client.find_subnet.assert_called_once_with(
self._subnet.name, ignore_missing=False
)
@ -1457,9 +1479,11 @@ class TestUnsetSubnet(TestSubnet):
'tags': ['green', 'red'],
}
)
self.network.find_subnet = mock.Mock(return_value=self._testsubnet)
self.network.update_subnet = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.find_subnet = mock.Mock(
return_value=self._testsubnet
)
self.network_client.update_subnet = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = subnet_v2.UnsetSubnet(self.app, self.namespace)
@ -1499,7 +1523,7 @@ class TestUnsetSubnet(TestSubnet):
'service_types': ['network:floatingip_agent_gateway'],
'gateway_ip': None,
}
self.network.update_subnet.assert_called_once_with(
self.network_client.update_subnet.assert_called_once_with(
self._testsubnet, **attrs
)
self.assertIsNone(result)
@ -1618,8 +1642,8 @@ class TestUnsetSubnet(TestSubnet):
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.assertFalse(self.network_client.update_subnet.called)
self.network_client.set_tags.assert_called_once_with(
self._testsubnet, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)

128
openstackclient/tests/unit/network/v2/test_subnet_pool.py

@ -29,7 +29,7 @@ class TestSubnetPool(network_fakes.TestNetworkV2):
super(TestSubnetPool, self).setUp()
# Get a shortcut to the network client
self.network = self.app.client_manager.network
self.network_client = self.app.client_manager.network
# Get a shortcut to the ProjectManager Mock
self.projects_mock = self.app.client_manager.identity.projects
# Get a shortcut to the DomainManager Mock
@ -80,15 +80,15 @@ class TestCreateSubnetPool(TestSubnetPool):
def setUp(self):
super(TestCreateSubnetPool, self).setUp()
self.network.create_subnet_pool = mock.Mock(
self.network_client.create_subnet_pool = mock.Mock(
return_value=self._subnet_pool
)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = subnet_pool.CreateSubnetPool(self.app, self.namespace)
self.network.find_address_scope = mock.Mock(
self.network_client.find_address_scope = mock.Mock(
return_value=self._address_scope
)
@ -106,7 +106,7 @@ class TestCreateSubnetPool(TestSubnetPool):
arglist,
verifylist,
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
def test_create_no_pool_prefix(self):
"""Make sure --pool-prefix is a required argument"""
@ -138,13 +138,13 @@ class TestCreateSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet_pool.assert_called_once_with(
self.network_client.create_subnet_pool.assert_called_once_with(
**{
'prefixes': ['10.0.10.0/24'],
'name': self._subnet_pool.name,
}
)
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -174,7 +174,7 @@ class TestCreateSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet_pool.assert_called_once_with(
self.network_client.create_subnet_pool.assert_called_once_with(
**{
'default_prefixlen': int(self._subnet_pool.default_prefixlen),
'max_prefixlen': int(self._subnet_pool.max_prefixlen),
@ -225,7 +225,7 @@ class TestCreateSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet_pool.assert_called_once_with(
self.network_client.create_subnet_pool.assert_called_once_with(
**{
'prefixes': ['10.0.10.0/24'],
'project_id': self.project.id,
@ -252,7 +252,7 @@ class TestCreateSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet_pool.assert_called_once_with(
self.network_client.create_subnet_pool.assert_called_once_with(
**{
'prefixes': ['10.0.10.0/24'],
'address_scope_id': self._address_scope.id,
@ -280,7 +280,7 @@ class TestCreateSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet_pool.assert_called_once_with(
self.network_client.create_subnet_pool.assert_called_once_with(
**{
'is_default': True,
'name': self._subnet_pool.name,
@ -308,7 +308,7 @@ class TestCreateSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.create_subnet_pool.assert_called_once_with(
self.network_client.create_subnet_pool.assert_called_once_with(
**{
'name': self._subnet_pool.name,
'prefixes': ['10.0.10.0/24'],
@ -333,7 +333,7 @@ class TestCreateSubnetPool(TestSubnetPool):
]
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(
self.network_client.create_subnet_pool.assert_called_once_with(
**{
'name': self._subnet_pool.name,
'prefixes': ['10.0.10.0/24'],
@ -365,15 +365,15 @@ class TestCreateSubnetPool(TestSubnetPool):
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(
self.network_client.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.network_client.set_tags.assert_called_once_with(
self._subnet_pool, tests_utils.CompareBySet(['red', 'blue'])
)
else:
self.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, data)
@ -391,9 +391,9 @@ class TestDeleteSubnetPool(TestSubnetPool):
def setUp(self):
super(TestDeleteSubnetPool, self).setUp()
self.network.delete_subnet_pool = mock.Mock(return_value=None)
self.network_client.delete_subnet_pool = mock.Mock(return_value=None)
self.network.find_subnet_pool = (
self.network_client.find_subnet_pool = (
network_fakes.FakeSubnetPool.get_subnet_pools(self._subnet_pools)
)
@ -411,7 +411,7 @@ class TestDeleteSubnetPool(TestSubnetPool):
result = self.cmd.take_action(parsed_args)
self.network.delete_subnet_pool.assert_called_once_with(
self.network_client.delete_subnet_pool.assert_called_once_with(
self._subnet_pools[0]
)
self.assertIsNone(result)
@ -432,7 +432,7 @@ class TestDeleteSubnetPool(TestSubnetPool):
calls = []
for s in self._subnet_pools:
calls.append(call(s))
self.network.delete_subnet_pool.assert_has_calls(calls)
self.network_client.delete_subnet_pool.assert_has_calls(calls)
self.assertIsNone(result)
def test_multi_subnet_pools_delete_with_exception(self):
@ -449,7 +449,9 @@ class TestDeleteSubnetPool(TestSubnetPool):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self._subnet_pools[0], exceptions.CommandError]
self.network.find_subnet_pool = mock.Mock(side_effect=find_mock_result)
self.network_client.find_subnet_pool = mock.Mock(
side_effect=find_mock_result
)
try:
self.cmd.take_action(parsed_args)
@ -457,13 +459,13 @@ class TestDeleteSubnetPool(TestSubnetPool):
except exceptions.CommandError as e:
self.assertEqual('1 of 2 subnet pools failed to delete.', str(e))
self.network.find_subnet_pool.assert_any_call(
self.network_client.find_subnet_pool.assert_any_call(
self._subnet_pools[0].name, ignore_missing=False
)
self.network.find_subnet_pool.assert_any_call(
self.network_client.find_subnet_pool.assert_any_call(
'unexist_subnet_pool', ignore_missing=False
)
self.network.delete_subnet_pool.assert_called_once_with(
self.network_client.delete_subnet_pool.assert_called_once_with(
self._subnet_pools[0]
)
@ -516,7 +518,9 @@ class TestListSubnetPool(TestSubnetPool):
# Get the command object to test
self.cmd = subnet_pool.ListSubnetPool(self.app, self.namespace)
self.network.subnet_pools = mock.Mock(return_value=self._subnet_pools)
self.network_client.subnet_pools = mock.Mock(
return_value=self._subnet_pools
)
def test_subnet_pool_list_no_option(self):
arglist = []
@ -527,7 +531,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.subnet_pools.assert_called_once_with()
self.network_client.subnet_pools.assert_called_once_with()
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -542,7 +546,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.subnet_pools.assert_called_once_with()
self.network_client.subnet_pools.assert_called_once_with()
self.assertEqual(self.columns_long, columns)
self.assertCountEqual(self.data_long, list(data))
@ -558,7 +562,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'shared': False, 'is_shared': False}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -574,7 +578,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'shared': True, 'is_shared': True}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -590,7 +594,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'is_default': False}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -606,7 +610,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'is_default': True}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -625,7 +629,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -647,13 +651,13 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'project_id': project.id}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
def test_subnet_pool_list_name(self):
subnet_pool = network_fakes.FakeSubnetPool.create_one_subnet_pool()
self.network.find_network = mock.Mock(return_value=subnet_pool)
self.network_client.find_network = mock.Mock(return_value=subnet_pool)
arglist = [
'--name',
subnet_pool.name,
@ -666,13 +670,15 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'name': subnet_pool.name}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
def test_subnet_pool_list_address_scope(self):
addr_scope = network_fakes.create_one_address_scope()
self.network.find_address_scope = mock.Mock(return_value=addr_scope)
self.network_client.find_address_scope = mock.Mock(
return_value=addr_scope
)
arglist = [
'--address-scope',
addr_scope.id,
@ -685,7 +691,7 @@ class TestListSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
filters = {'address_scope_id': addr_scope.id}
self.network.subnet_pools.assert_called_once_with(**filters)
self.network_client.subnet_pools.assert_called_once_with(**filters)
self.assertEqual(self.columns, columns)
self.assertCountEqual(self.data, list(data))
@ -709,7 +715,7 @@ class TestListSubnetPool(TestSubnetPool):
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.network.subnet_pools.assert_called_once_with(
self.network_client.subnet_pools.assert_called_once_with(
**{
'tags': 'red,blue',
'any_tags': 'red,green',
@ -732,14 +738,14 @@ class TestSetSubnetPool(TestSubnetPool):
def setUp(self):
super(TestSetSubnetPool, self).setUp()
self.network.update_subnet_pool = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.update_subnet_pool = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
self.network.find_subnet_pool = mock.Mock(
self.network_client.find_subnet_pool = mock.Mock(
return_value=self._subnet_pool
)
self.network.find_address_scope = mock.Mock(
self.network_client.find_address_scope = mock.Mock(
return_value=self._address_scope
)
@ -771,7 +777,7 @@ class TestSetSubnetPool(TestSubnetPool):
'default_prefixlen': 8,
'min_prefixlen': 8,
}
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool, **attrs
)
self.assertIsNone(result)
@ -801,7 +807,7 @@ class TestSetSubnetPool(TestSubnetPool):
'prefixes': prefixes,
'max_prefixlen': 16,
}
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool, **attrs
)
self.assertIsNone(result)
@ -817,8 +823,8 @@ class TestSetSubnetPool(TestSubnetPool):
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.assertFalse(self.network.set_tags.called)
self.assertFalse(self.network_client.update_subnet_pool.called)
self.assertFalse(self.network_client.set_tags.called)
self.assertIsNone(result)
def test_set_len_negative(self):
@ -857,7 +863,7 @@ class TestSetSubnetPool(TestSubnetPool):
attrs = {
'address_scope_id': self._address_scope.id,
}
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool, **attrs
)
self.assertIsNone(result)
@ -878,7 +884,7 @@ class TestSetSubnetPool(TestSubnetPool):
attrs = {
'address_scope_id': None,
}
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool, **attrs
)
self.assertIsNone(result)
@ -919,7 +925,7 @@ class TestSetSubnetPool(TestSubnetPool):
result = self.cmd.take_action(parsed_args)
attrs = {'is_default': True}
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool, **attrs
)
self.assertIsNone(result)
@ -940,7 +946,7 @@ class TestSetSubnetPool(TestSubnetPool):
attrs = {
'is_default': False,
}
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool, **attrs
)
self.assertIsNone(result)
@ -983,7 +989,7 @@ class TestSetSubnetPool(TestSubnetPool):
attrs = {
'description': "new_description",
}
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool, **attrs
)
self.assertIsNone(result)
@ -1000,7 +1006,7 @@ class TestSetSubnetPool(TestSubnetPool):
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.network.update_subnet_pool.assert_called_once_with(
self.network_client.update_subnet_pool.assert_called_once_with(
self._subnet_pool,
**{
'default_quota': 20,
@ -1023,8 +1029,8 @@ class TestSetSubnetPool(TestSubnetPool):
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.assertFalse(self.network_client.update_subnet_pool.called)
self.network_client.set_tags.assert_called_once_with(
self._subnet_pool, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)
@ -1077,7 +1083,7 @@ class TestShowSubnetPool(TestSubnetPool):
def setUp(self):
super(TestShowSubnetPool, self).setUp()
self.network.find_subnet_pool = mock.Mock(
self.network_client.find_subnet_pool = mock.Mock(
return_value=self._subnet_pool
)
@ -1107,7 +1113,7 @@ class TestShowSubnetPool(TestSubnetPool):
columns, data = self.cmd.take_action(parsed_args)
self.network.find_subnet_pool.assert_called_once_with(
self.network_client.find_subnet_pool.assert_called_once_with(
self._subnet_pool.name, ignore_missing=False
)
self.assertEqual(self.columns, columns)
@ -1120,11 +1126,11 @@ class TestUnsetSubnetPool(TestSubnetPool):
self._subnetpool = network_fakes.FakeSubnetPool.create_one_subnet_pool(
{'tags': ['green', 'red']}
)
self.network.find_subnet_pool = mock.Mock(
self.network_client.find_subnet_pool = mock.Mock(
return_value=self._subnetpool
)
self.network.update_subnet_pool = mock.Mock(return_value=None)
self.network.set_tags = mock.Mock(return_value=None)
self.network_client.update_subnet_pool = mock.Mock(return_value=None)
self.network_client.set_tags = mock.Mock(return_value=None)
# Get the command object to test
self.cmd = subnet_pool.UnsetSubnetPool(self.app, self.namespace)
@ -1143,8 +1149,8 @@ class TestUnsetSubnetPool(TestSubnetPool):
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.assertFalse(self.network_client.update_subnet_pool.called)
self.network_client.set_tags.assert_called_once_with(
self._subnetpool, tests_utils.CompareBySet(expected_args)
)
self.assertIsNone(result)