From 5e012b45fc028f5a7ec4333be247acf03f9c3eac Mon Sep 17 00:00:00 2001
From: Akihiro Motoki <amotoki@gmail.com>
Date: Mon, 14 May 2018 09:18:40 +0900
Subject: [PATCH] Convert admin.networks tests into mock
blueprint mock-framework-in-unit-tests
Change-Id: Id9b40bf44c5ab46e7af6c5fa1dea96663c38f3dd
---
.../dashboards/admin/networks/tests.py | 1055 +++++++++--------
1 file changed, 550 insertions(+), 505 deletions(-)
diff --git a/openstack_dashboard/dashboards/admin/networks/tests.py b/openstack_dashboard/dashboards/admin/networks/tests.py
index 68c3b646df..1cb64b9f08 100644
--- a/openstack_dashboard/dashboards/admin/networks/tests.py
+++ b/openstack_dashboard/dashboards/admin/networks/tests.py
@@ -12,12 +12,12 @@
# License for the specific language governing permissions and limitations
# under the License.
+import collections
-from django import http
from django.urls import reverse
from django.utils.http import urlunquote
-from mox3.mox import IsA
+import mock
from horizon import forms
@@ -32,9 +32,20 @@ INDEX_URL = reverse('horizon:admin:networks:index')
class NetworkTests(test.BaseAdminViewTests):
- use_mox = True
+ def _stub_is_extension_supported(self, features):
+ self._features = features
+ self._feature_call_counts = collections.defaultdict(int)
- @test.create_stubs({api.neutron: ('network_list',
+ def fake_extension_supported(request, alias):
+ self._feature_call_counts[alias] += 1
+ return self._features[alias]
+
+ self.mock_is_extension_supported.side_effect = fake_extension_supported
+
+ def _check_is_extension_supported(self, expected_count):
+ self.assertEqual(expected_count, self._feature_call_counts)
+
+ @test.create_mocks({api.neutron: ('network_list',
'list_dhcp_agent_hosting_networks',
'is_extension_supported'),
api.keystone: ('tenant_list',),
@@ -42,28 +53,15 @@ class NetworkTests(test.BaseAdminViewTests):
def test_index(self):
tenants = self.tenants.list()
quota_data = self.quota_usages.first()
- api.neutron.network_list(IsA(http.HttpRequest)) \
- .AndReturn(self.networks.list())
- api.keystone.tenant_list(IsA(http.HttpRequest))\
- .AndReturn([tenants, False])
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- for network in self.networks.list():
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('subnet', )).AndReturn(quota_data)
- api.neutron.list_dhcp_agent_hosting_networks(IsA(http.HttpRequest),
- network.id)\
- .AndReturn(self.agents.list())
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_network_list.return_value = self.networks.list()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+ self.mock_tenant_quota_usages.return_value = quota_data
+ self.mock_list_dhcp_agent_hosting_networks.return_value = \
+ self.agents.list()
res = self.client.get(INDEX_URL)
@@ -71,19 +69,30 @@ class NetworkTests(test.BaseAdminViewTests):
networks = res.context['networks_table'].data
self.assertItemsEqual(networks, self.networks.list())
- @test.create_stubs({api.neutron: ('network_list',
+ self.mock_network_list.assert_called_once_with(test.IsHttpRequest())
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': len(self.networks.list()) + 1})
+ self.mock_tenant_quota_usages.assert_has_calls(
+ [mock.call(test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('subnet', ))
+ for network in self.networks.list()])
+ self.assertEqual(len(self.networks.list()),
+ self.mock_tenant_quota_usages.call_count)
+ self.mock_list_dhcp_agent_hosting_networks.assert_has_calls(
+ [mock.call(test.IsHttpRequest(), network.id)
+ for network in self.networks.list()])
+ self.assertEqual(len(self.networks.list()),
+ self.mock_list_dhcp_agent_hosting_networks.call_count)
+
+ @test.create_mocks({api.neutron: ('network_list',
'is_extension_supported',)})
def test_index_network_list_exception(self):
- api.neutron.network_list(IsA(http.HttpRequest)) \
- .AndRaise(self.exceptions.neutron)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
-
- self.mox.ReplayAll()
+ self.mock_network_list.side_effect = self.exceptions.neutron
+ self._stub_is_extension_supported(
+ {'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
res = self.client.get(INDEX_URL)
@@ -91,51 +100,26 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertEqual(len(res.context['networks_table'].data), 0)
self.assertMessageCount(res, error=1)
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'show_network_ip_availability',
- 'list_dhcp_agent_hosting_networks',
- 'is_extension_supported'),
- usage.quotas: ('tenant_quota_usages',)})
- def test_network_detail_subnets_tab(self):
- self._test_network_detail_subnets_tab()
+ self.mock_network_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 1})
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'is_extension_supported',
- 'show_network_ip_availability',
- 'list_dhcp_agent_hosting_networks',),
- usage.quotas: ('tenant_quota_usages',)})
- def test_network_detail_subnets_tab_with_mac_learning(self):
- self._test_network_detail_subnets_tab(mac_learning=True)
-
- @test.create_stubs({api.neutron: ('network_get',
+ @test.create_mocks({api.neutron: ('network_get',
'is_extension_supported'),
usage.quotas: ('tenant_quota_usages',)})
def test_network_detail_new(self, mac_learning=False):
network = self.networks.first()
quota_data = self.quota_usages.first()
- api.neutron.network_get(IsA(http.HttpRequest), network.id) \
- .MultipleTimes().AndReturn(self.networks.first())
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network-ip-availability') \
- .AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'mac-learning') \
- .AndReturn(mac_learning)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('subnet',)).MultipleTimes().AndReturn(quota_data)
- self.mox.ReplayAll()
+ self.mock_network_get.return_value = network
+ self.mock_tenant_quota_usages.return_value = quota_data
+ self._stub_is_extension_supported(
+ {'network-ip-availability': True,
+ 'network_availability_zone': True,
+ 'mac-learning': mac_learning,
+ 'dhcp_agent_scheduler': True})
+
url = urlunquote(reverse('horizon:admin:networks:detail',
args=[network.id]))
@@ -146,37 +130,44 @@ class NetworkTests(test.BaseAdminViewTests):
network.status_label)
self.assertTemplateUsed(res, 'horizon/common/_detail.html')
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_network_get, 2,
+ mock.call(test.IsHttpRequest(), network.id))
+ self.mock_tenant_quota_usages.assert_called_once_with(
+ test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('subnet',))
+ self._check_is_extension_supported(
+ {'network-ip-availability': 1,
+ 'network_availability_zone': 1,
+ 'mac-learning': 1,
+ 'dhcp_agent_scheduler': 1})
+
+ def test_network_detail_subnets_tab(self):
+ self._test_network_detail_subnets_tab()
+
+ def test_network_detail_subnets_tab_with_mac_learning(self):
+ self._test_network_detail_subnets_tab(mac_learning=True)
+
+ @test.create_mocks({api.neutron: ('network_get',
+ 'subnet_list',
+ 'show_network_ip_availability',
+ 'is_extension_supported'),
+ usage.quotas: ('tenant_quota_usages',)})
def _test_network_detail_subnets_tab(self, mac_learning=False):
network = self.networks.first()
ip_availability = self.ip_availability.get()
quota_data = self.quota_usages.first()
- api.neutron.show_network_ip_availability(IsA(http.HttpRequest),
- network.id).\
- MultipleTimes().AndReturn(ip_availability)
- api.neutron.network_get(IsA(http.HttpRequest), network.id)\
- .MultipleTimes().AndReturn(self.networks.first())
- api.neutron.subnet_list(IsA(http.HttpRequest), network_id=network.id)\
- .AndReturn([self.subnets.first()])
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'mac-learning')\
- .AndReturn(mac_learning)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('subnet',)).MultipleTimes().AndReturn(quota_data)
- self.mox.ReplayAll()
+ self.mock_show_network_ip_availability.return_value = ip_availability
+ self.mock_network_get.return_value = network
+ self.mock_subnet_list.return_value = [self.subnets.first()]
+ self._stub_is_extension_supported(
+ {'network-ip-availability': True,
+ 'mac-learning': mac_learning,
+ 'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+ self.mock_tenant_quota_usages.return_value = quota_data
+
url = urlunquote(reverse('horizon:admin:networks:subnets_tab',
args=[network.id]))
res = self.client.get(url)
@@ -185,39 +176,40 @@ class NetworkTests(test.BaseAdminViewTests):
subnets = res.context['subnets_table'].data
self.assertItemsEqual(subnets, [self.subnets.first()])
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
+ self.mock_show_network_ip_availability.assert_called_once_with(
+ test.IsHttpRequest(), network.id)
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_network_get, 2,
+ mock.call(test.IsHttpRequest(), network.id))
+ self.mock_subnet_list.assert_called_once_with(test.IsHttpRequest(),
+ network_id=network.id)
+ self._check_is_extension_supported(
+ {'network-ip-availability': 2,
+ 'mac-learning': 1,
+ 'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 1})
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_tenant_quota_usages, 3,
+ mock.call(test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('subnet',)))
+
+ @test.create_mocks({api.neutron: ('network_get',
'port_list',
- 'is_extension_supported',
- 'list_dhcp_agent_hosting_networks',),
+ 'is_extension_supported'),
usage.quotas: ('tenant_quota_usages',)})
def test_network_detail_ports_tab(self, mac_learning=False):
network = self.networks.first()
- api.neutron.network_get(IsA(http.HttpRequest), network.id)\
- .MultipleTimes().AndReturn(self.networks.first())
- api.neutron.port_list(IsA(http.HttpRequest), network_id=network.id)\
- .AndReturn([self.ports.first()])
quota_data = self.neutron_quota_usages.first()
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('port',)).MultipleTimes().AndReturn(quota_data)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'mac-learning')\
- .AndReturn(mac_learning)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('subnet',)).MultipleTimes().AndReturn(quota_data)
- self.mox.ReplayAll()
+ self.mock_network_get.return_value = network
+ self.mock_port_list.return_value = [self.ports.first()]
+ self.mock_tenant_quota_usages.return_value = quota_data
+ self._stub_is_extension_supported(
+ {'network-ip-availability': True,
+ 'mac-learning': mac_learning,
+ 'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+
url = reverse('horizon:admin:networks:ports_tab',
args=[network.id])
res = self.client.get(urlunquote(url))
@@ -226,40 +218,44 @@ class NetworkTests(test.BaseAdminViewTests):
ports = res.context['ports_table'].data
self.assertItemsEqual(ports, [self.ports.first()])
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_network_get, 2,
+ mock.call(test.IsHttpRequest(), network.id))
+ self.mock_port_list.assert_called_once_with(test.IsHttpRequest(),
+ network_id=network.id)
+ self.assertEqual(3, self.mock_tenant_quota_usages.call_count)
+ self.mock_tenant_quota_usages.assert_has_calls([
+ mock.call(test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('subnet',)),
+ mock.call(test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('port',)),
+ mock.call(test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('port',)),
+ ])
+ self._check_is_extension_supported(
+ {'network-ip-availability': 1,
+ 'mac-learning': 1,
+ 'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 1})
+
+ @test.create_mocks({api.neutron: ('network_get',
'is_extension_supported',
'list_dhcp_agent_hosting_networks',),
usage.quotas: ('tenant_quota_usages',)})
def test_network_detail_agents_tab(self, mac_learning=False):
network = self.networks.first()
quota_data = self.quota_usages.first()
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network-ip-availability') \
- .AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'mac-learning')\
- .AndReturn(mac_learning)
- api.neutron.list_dhcp_agent_hosting_networks(IsA(http.HttpRequest),
- network.id)\
- .AndReturn(self.agents.list())
- api.neutron.network_get(IsA(http.HttpRequest), network.id)\
- .MultipleTimes().AndReturn(self.networks.first())
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('subnet',)).MultipleTimes().AndReturn(quota_data)
- self.mox.ReplayAll()
+ self._stub_is_extension_supported(
+ {'network-ip-availability': True,
+ 'mac-learning': mac_learning,
+ 'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+ self.mock_list_dhcp_agent_hosting_networks.return_value = \
+ self.agents.list()
+ self.mock_network_get.return_value = network
+ self.mock_tenant_quota_usages.return_value = quota_data
+
url = reverse('horizon:admin:networks:agents_tab', args=[network.id])
res = self.client.get(urlunquote(url))
@@ -269,47 +265,41 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertItemsEqual(result_agents, expected_agents)
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'is_extension_supported',
- 'show_network_ip_availability',
- 'list_dhcp_agent_hosting_networks',)})
+ self._check_is_extension_supported(
+ {'network-ip-availability': 1,
+ 'mac-learning': 1,
+ 'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 2})
+ self.mock_list_dhcp_agent_hosting_networks.assert_called_once_with(
+ test.IsHttpRequest(), network.id)
+ self.mock_network_get.assert_called_once_with(
+ test.IsHttpRequest(), network.id)
+ self.mock_tenant_quota_usages.assert_called_once_with(
+ test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('subnet',))
+
def test_network_detail_subnets_tab_network_exception(self):
self._test_network_detail_subnets_tab_network_exception()
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'is_extension_supported',
- 'show_network_ip_availability',
- 'list_dhcp_agent_hosting_networks',)})
def test_network_detail_network_exception_with_mac_learning(self):
self._test_network_detail_subnets_tab_network_exception(
mac_learning=True)
+ @test.create_mocks({api.neutron: ('network_get',
+ 'subnet_list',
+ 'is_extension_supported',
+ 'show_network_ip_availability')})
def _test_network_detail_subnets_tab_network_exception(self,
mac_learning=False):
network_id = self.networks.first().id
ip_availability = self.ip_availability.get()
- api.neutron.show_network_ip_availability(IsA(http.HttpRequest),
- network_id).\
- MultipleTimes().AndReturn(ip_availability)
- api.neutron.network_get(IsA(http.HttpRequest), network_id)\
- .AndRaise(self.exceptions.neutron)
- api.neutron.subnet_list(IsA(http.HttpRequest), network_id=network_id)\
- .AndReturn([self.subnets.first()])
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'mac-learning')\
- .AndReturn(mac_learning)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_show_network_ip_availability.return_value = ip_availability
+ self.mock_network_get.side_effect = self.exceptions.neutron
+ self.mock_subnet_list.return_value = [self.subnets.first()]
+ self._stub_is_extension_supported(
+ {'network-ip-availability': True,
+ 'mac-learning': mac_learning})
url = urlunquote(reverse('horizon:admin:networks:subnets_tab',
args=[network_id]))
@@ -318,52 +308,44 @@ class NetworkTests(test.BaseAdminViewTests):
redir_url = INDEX_URL
self.assertRedirectsNoFollow(res, redir_url)
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'list_dhcp_agent_hosting_networks',
- 'is_extension_supported'),
- usage.quotas: ('tenant_quota_usages',)})
+ self.mock_show_network_ip_availability.assert_called_once_with(
+ test.IsHttpRequest(), network_id)
+ self.mock_network_get.assert_called_once_with(test.IsHttpRequest(),
+ network_id)
+ self.mock_subnet_list.assert_called_once_with(test.IsHttpRequest(),
+ network_id=network_id)
+ self._check_is_extension_supported(
+ {'network-ip-availability': 2,
+ 'mac-learning': 1})
+
def test_network_detail_subnets_tab_subnet_exception(self):
self._test_network_detail_subnets_tab_subnet_exception()
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'is_extension_supported',
- 'list_dhcp_agent_hosting_networks',),
- usage.quotas: ('tenant_quota_usages',)})
def test_network_detail_subnets_tab_subnet_exception_w_mac_learning(self):
self._test_network_detail_subnets_tab_subnet_exception(
mac_learning=True)
+ @test.create_mocks({api.neutron: ('network_get',
+ 'subnet_list',
+ 'show_network_ip_availability',
+ 'is_extension_supported'),
+ usage.quotas: ('tenant_quota_usages',)})
def _test_network_detail_subnets_tab_subnet_exception(self,
mac_learning=False):
network = self.networks.first()
quota_data = self.quota_usages.first()
- api.neutron.network_get(IsA(http.HttpRequest), network.id)\
- .MultipleTimes().AndReturn(self.networks.first())
- api.neutron.subnet_list(IsA(http.HttpRequest), network_id=network.id).\
- AndRaise(self.exceptions.neutron)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'mac-learning')\
- .AndReturn(mac_learning)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('subnet',)).MultipleTimes().AndReturn(quota_data)
- self.mox.ReplayAll()
+
+ self.mock_show_network_ip_availability.return_value = \
+ self.ip_availability.get()
+ self.mock_network_get.return_value = network
+ self.mock_subnet_list.side_effect = self.exceptions.neutron
+ self._stub_is_extension_supported(
+ {'network-ip-availability': True,
+ 'mac-learning': mac_learning,
+ 'dhcp_agent_scheduler': True,
+ 'network_availability_zone': True})
+ self.mock_tenant_quota_usages.return_value = quota_data
+
url = urlunquote(reverse('horizon:admin:networks:subnets_tab',
args=[network.id]))
res = self.client.get(url)
@@ -372,57 +354,50 @@ class NetworkTests(test.BaseAdminViewTests):
subnets = res.context['subnets_table'].data
self.assertEqual(len(subnets), 0)
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'is_extension_supported',
- 'show_network_ip_availability',
- 'list_dhcp_agent_hosting_networks',),
- usage.quotas: ('tenant_quota_usages',)})
+ self.mock_show_network_ip_availability.assert_called_once_with(
+ test.IsHttpRequest(), network.id)
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_network_get, 2,
+ mock.call(test.IsHttpRequest(), network.id))
+ self.mock_subnet_list.assert_called_once_with(test.IsHttpRequest(),
+ network_id=network.id)
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_tenant_quota_usages, 3,
+ mock.call(test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('subnet',)))
+ self._stub_is_extension_supported(
+ {'network-ip-availability': 1,
+ 'mac-learning': 1,
+ 'dhcp_agent_scheduler': 2,
+ 'network_availability_zone': 1})
+
def test_network_detail_port_exception(self):
self._test_network_detail_subnets_tab_port_exception()
- @test.create_stubs({api.neutron: ('network_get',
- 'subnet_list',
- 'port_list',
- 'is_extension_supported',
- 'show_network_ip_availability',
- 'list_dhcp_agent_hosting_networks',),
- usage.quotas: ('tenant_quota_usages',)})
def test_network_detail_subnets_tab_port_exception_with_mac_learning(self):
self._test_network_detail_subnets_tab_port_exception(mac_learning=True)
+ @test.create_mocks({api.neutron: ('network_get',
+ 'subnet_list',
+ 'is_extension_supported',
+ 'show_network_ip_availability'),
+ usage.quotas: ('tenant_quota_usages',)})
def _test_network_detail_subnets_tab_port_exception(self,
mac_learning=False):
network = self.networks.first()
ip_availability = self.ip_availability.get()
quota_data = self.quota_usages.first()
- api.neutron.show_network_ip_availability(IsA(http.HttpRequest),
- network.id). \
- MultipleTimes().AndReturn(ip_availability)
- api.neutron.network_get(IsA(http.HttpRequest), network.id)\
- .MultipleTimes().AndReturn(self.networks.first())
- api.neutron.subnet_list(IsA(http.HttpRequest), network_id=network.id).\
- AndReturn([self.subnets.first()])
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'mac-learning')\
- .AndReturn(mac_learning)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network-ip-availability').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'dhcp_agent_scheduler')\
- .AndReturn(True)
- usage.quotas.tenant_quota_usages(
- IsA(http.HttpRequest), tenant_id=network.tenant_id,
- targets=('subnet',)).MultipleTimes().AndReturn(quota_data)
- self.mox.ReplayAll()
+
+ self.mock_show_network_ip_availability.return_value = ip_availability
+ self.mock_network_get.return_value = network
+ self.mock_subnet_list.return_value = [self.subnets.first()]
+ self._stub_is_extension_supported(
+ {'network-ip-availability': True,
+ 'mac-learning': mac_learning,
+ 'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+ self.mock_tenant_quota_usages.return_value = quota_data
+
url = urlunquote(reverse('horizon:admin:networks:subnets_tab',
args=[network.id]))
res = self.client.get(url)
@@ -431,22 +406,45 @@ class NetworkTests(test.BaseAdminViewTests):
subnets = res.context['subnets_table'].data
self.assertItemsEqual(subnets, [self.subnets.first()])
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self.mock_show_network_ip_availability.assert_called_once_with(
+ test.IsHttpRequest(), network.id)
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_network_get, 2,
+ mock.call(test.IsHttpRequest(), network.id))
+ self.mock_subnet_list.assert_called_once_with(test.IsHttpRequest(),
+ network_id=network.id)
+ self._check_is_extension_supported(
+ {'network-ip-availability': 2,
+ 'mac-learning': 1,
+ 'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 1})
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_tenant_quota_usages, 3,
+ mock.call(test.IsHttpRequest(), tenant_id=network.tenant_id,
+ targets=('subnet',)))
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
def test_network_create_get(self):
tenants = self.tenants.list()
- api.keystone.tenant_list(IsA(
- http.HttpRequest)).AndReturn([tenants, False])
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'provider': True,
+ 'network_availability_zone': False,
+ 'subnet_allocation': False})
url = reverse('horizon:admin:networks:create')
res = self.client.get(url)
self.assertTemplateUsed(res, 'horizon/common/_workflow_base.html')
- @test.create_stubs({api.neutron: ('network_create',
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'provider': 1,
+ 'network_availability_zone': 2,
+ 'subnet_allocation': 1})
+
+ @test.create_mocks({api.neutron: ('network_create',
'is_extension_supported',
'subnetpool_list'),
api.keystone: ('tenant_list',)})
@@ -455,29 +453,13 @@ class NetworkTests(test.BaseAdminViewTests):
tenant_id = self.tenants.first().id
network = self.networks.first()
- api.keystone.tenant_list(IsA(http.HttpRequest))\
- .AndReturn([tenants, False])
- params = {'name': network.name,
- 'tenant_id': tenant_id,
- 'admin_state_up': network.admin_state_up,
- 'router:external': True,
- 'shared': True,
- 'provider:network_type': 'local',
- 'with_subnet': False}
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- MultipleTimes().AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network_availability_zone').\
- MultipleTimes().AndReturn(False)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'subnet_allocation').\
- MultipleTimes().AndReturn(True)
- api.neutron.subnetpool_list(IsA(http.HttpRequest)).\
- AndReturn(self.subnetpools.list())
- api.neutron.network_create(IsA(http.HttpRequest), **params)\
- .AndReturn(network)
-
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'provider': True,
+ 'network_availability_zone': False,
+ 'subnet_allocation': True})
+ self.mock_subnetpool_list.return_value = self.subnetpools.list()
+ self.mock_network_create.return_value = network
form_data = {'tenant_id': tenant_id,
'name': network.name,
@@ -491,7 +473,22 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertNoFormErrors(res)
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('network_create',
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self.mock_subnetpool_list.assert_called_once_with(test.IsHttpRequest())
+ params = {'name': network.name,
+ 'tenant_id': tenant_id,
+ 'admin_state_up': network.admin_state_up,
+ 'router:external': True,
+ 'shared': True,
+ 'provider:network_type': 'local'}
+ self.mock_network_create.assert_called_once_with(test.IsHttpRequest(),
+ **params)
+ self._check_is_extension_supported(
+ {'provider': 3,
+ 'network_availability_zone': 2,
+ 'subnet_allocation': 1})
+
+ @test.create_mocks({api.neutron: ('network_create',
'is_extension_supported',
'list_availability_zones',
'subnetpool_list'),
@@ -501,33 +498,15 @@ class NetworkTests(test.BaseAdminViewTests):
tenant_id = self.tenants.first().id
network = self.networks.first()
- api.keystone.tenant_list(IsA(http.HttpRequest))\
- .AndReturn([tenants, False])
- params = {'name': network.name,
- 'tenant_id': tenant_id,
- 'admin_state_up': network.admin_state_up,
- 'router:external': True,
- 'shared': True,
- 'provider:network_type': 'local',
- 'with_subnet': False,
- 'az_hints': ['nova']}
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- MultipleTimes().AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network_availability_zone').\
- MultipleTimes().AndReturn(True)
- api.neutron.list_availability_zones(IsA(http.HttpRequest),
- "network", "available")\
- .AndReturn(self.neutron_availability_zones.list())
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'subnet_allocation').\
- MultipleTimes().AndReturn(True)
- api.neutron.subnetpool_list(IsA(http.HttpRequest)).\
- AndReturn(self.subnetpools.list())
- api.neutron.network_create(IsA(http.HttpRequest), **params)\
- .AndReturn(network)
-
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'provider': True,
+ 'network_availability_zone': True,
+ 'subnet_allocation': True})
+ self.mock_list_availability_zones.return_value = \
+ self.neutron_availability_zones.list()
+ self.mock_subnetpool_list.return_value = self.subnetpools.list()
+ self.mock_network_create.return_value = network
form_data = {'tenant_id': tenant_id,
'name': network.name,
@@ -535,14 +514,33 @@ class NetworkTests(test.BaseAdminViewTests):
'external': True,
'shared': True,
'network_type': 'local',
- 'availability_zone_hints': ['nova']}
+ 'az_hints': ['nova']}
url = reverse('horizon:admin:networks:create')
res = self.client.post(url, form_data)
self.assertNoFormErrors(res)
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('network_create',
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._stub_is_extension_supported(
+ {'provider': 1,
+ 'network_availability_zone': 1,
+ 'subnet_allocation': 1})
+ self.assert_mock_multiple_calls_with_same_arguments(
+ self.mock_list_availability_zones, 2,
+ mock.call(test.IsHttpRequest(), "network", "available"))
+ self.mock_subnetpool_list.assert_called_once_with(test.IsHttpRequest())
+ params = {'name': network.name,
+ 'tenant_id': tenant_id,
+ 'admin_state_up': network.admin_state_up,
+ 'router:external': True,
+ 'shared': True,
+ 'provider:network_type': 'local',
+ 'availability_zone_hints': ['nova']}
+ self.mock_network_create.assert_called_once_with(test.IsHttpRequest(),
+ **params)
+
+ @test.create_mocks({api.neutron: ('network_create',
'subnet_create',
'is_extension_supported',
'subnetpool_list'),
@@ -552,30 +550,15 @@ class NetworkTests(test.BaseAdminViewTests):
tenant_id = self.tenants.first().id
network = self.networks.first()
subnet = self.subnets.first()
- params = {'name': network.name,
- 'tenant_id': tenant_id,
- 'admin_state_up': network.admin_state_up,
- 'router:external': True,
- 'shared': True,
- 'provider:network_type': 'local',
- 'with_subnet': True}
- api.keystone.tenant_list(IsA(http.HttpRequest))\
- .AndReturn([tenants, False])
-
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- MultipleTimes().AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network_availability_zone').\
- MultipleTimes().AndReturn(False)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'subnet_allocation').\
- MultipleTimes().AndReturn(True)
- api.neutron.subnetpool_list(IsA(http.HttpRequest)).\
- AndReturn(self.subnetpools.list())
- api.neutron.network_create(IsA(http.HttpRequest), **params)\
- .AndReturn(network)
- self.mox.ReplayAll()
+ self._stub_is_extension_supported(
+ {'provider': True,
+ 'network_availability_zone': False,
+ 'subnet_allocation': True})
+ self.mock_tenant_list.return_value = [tenants, False]
+ self.mock_subnetpool_list.return_value = self.subnetpools.list()
+ self.mock_network_create.return_value = network
+ self.mock_subnet_create.return_value = subnet
form_data = {'tenant_id': tenant_id,
'name': network.name,
@@ -591,7 +574,30 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertNoFormErrors(res)
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('network_create',
+ self._check_is_extension_supported(
+ {'provider': 3,
+ 'network_availability_zone': 2,
+ 'subnet_allocation': 1})
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self.mock_subnetpool_list.assert_called_once_with(test.IsHttpRequest())
+ params = {'name': network.name,
+ 'tenant_id': tenant_id,
+ 'admin_state_up': network.admin_state_up,
+ 'router:external': True,
+ 'shared': True,
+ 'provider:network_type': 'local'}
+ self.mock_network_create.assert_called_once_with(test.IsHttpRequest(),
+ **params)
+ subnet_params = {'name': subnet.name,
+ 'network_id': subnet.network_id,
+ 'cidr': subnet.cidr,
+ 'enable_dhcp': subnet.enable_dhcp,
+ 'gateway_ip': subnet.gateway_ip,
+ 'ip_version': subnet.ip_version}
+ self.mock_subnet_create.assert_called_once_with(test.IsHttpRequest(),
+ **subnet_params)
+
+ @test.create_mocks({api.neutron: ('network_create',
'is_extension_supported',
'subnetpool_list'),
api.keystone: ('tenant_list',)})
@@ -600,28 +606,13 @@ class NetworkTests(test.BaseAdminViewTests):
tenant_id = self.tenants.first().id
network = self.networks.first()
- api.keystone.tenant_list(IsA(http.HttpRequest)).AndReturn([tenants,
- False])
- params = {'name': network.name,
- 'tenant_id': tenant_id,
- 'admin_state_up': network.admin_state_up,
- 'router:external': True,
- 'shared': False,
- 'provider:network_type': 'local',
- 'with_subnet': False}
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- MultipleTimes().AndReturn(True)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network_availability_zone').\
- MultipleTimes().AndReturn(False)
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'subnet_allocation').\
- MultipleTimes().AndReturn(True)
- api.neutron.subnetpool_list(IsA(http.HttpRequest)).\
- AndReturn(self.subnetpools.list())
- api.neutron.network_create(IsA(http.HttpRequest),
- **params).AndRaise(self.exceptions.neutron)
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'provider': True,
+ 'network_availability_zone': False,
+ 'subnet_allocation': True})
+ self.mock_subnetpool_list.return_value = self.subnetpools.list()
+ self.mock_network_create.side_effect = self.exceptions.neutron
form_data = {'tenant_id': tenant_id,
'name': network.name,
@@ -635,22 +626,33 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertNoFormErrors(res)
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'provider': 3,
+ 'network_availability_zone': 2,
+ 'subnet_allocation': 1})
+ self.mock_subnetpool_list.assert_called_once_with(test.IsHttpRequest())
+ params = {'name': network.name,
+ 'tenant_id': tenant_id,
+ 'admin_state_up': network.admin_state_up,
+ 'router:external': True,
+ 'shared': False,
+ 'provider:network_type': 'local'}
+ self.mock_network_create.assert_called_once_with(test.IsHttpRequest(),
+ **params)
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
def test_network_create_vlan_segmentation_id_invalid(self):
tenants = self.tenants.list()
tenant_id = self.tenants.first().id
network = self.networks.first()
- api.keystone.tenant_list(
- IsA(http.HttpRequest)
- ).MultipleTimes().AndReturn([tenants, False])
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network_availability_zone').\
- MultipleTimes().AndReturn(False)
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider')\
- .MultipleTimes().AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'network_availability_zone': False,
+ 'subnet_allocation': False,
+ 'provider': True})
form_data = {'tenant_id': tenant_id,
'name': network.name,
@@ -666,23 +668,24 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertFormErrors(res, 1)
self.assertContains(res, "1 through 4094")
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'network_availability_zone': 2,
+ 'subnet_allocation': 1,
+ 'provider': 2})
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
def test_network_create_gre_segmentation_id_invalid(self):
tenants = self.tenants.list()
tenant_id = self.tenants.first().id
network = self.networks.first()
- api.keystone.tenant_list(
- IsA(http.HttpRequest)
- ).MultipleTimes().AndReturn([tenants, False])
-
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network_availability_zone').\
- MultipleTimes().AndReturn(False)
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- MultipleTimes().AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'network_availability_zone': False,
+ 'subnet_allocation': False,
+ 'provider': True})
form_data = {'tenant_id': tenant_id,
'name': network.name,
@@ -698,7 +701,13 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertFormErrors(res, 1)
self.assertContains(res, "1 through %s" % ((2 ** 32) - 1))
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'network_availability_zone': 2,
+ 'subnet_allocation': 1,
+ 'provider': 2})
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
@test.update_settings(
OPENSTACK_NEUTRON_NETWORK={
@@ -707,17 +716,12 @@ class NetworkTests(test.BaseAdminViewTests):
tenants = self.tenants.list()
tenant_id = self.tenants.first().id
network = self.networks.first()
- api.keystone.tenant_list(
- IsA(http.HttpRequest)
- ).MultipleTimes().AndReturn([tenants, False])
- api.neutron.is_extension_supported(IsA(http.HttpRequest),
- 'network_availability_zone').\
- MultipleTimes().AndReturn(False)
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider')\
- .MultipleTimes().AndReturn(True)
-
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'network_availability_zone': False,
+ 'subnet_allocation': False,
+ 'provider': True})
form_data = {'tenant_id': tenant_id,
'name': network.name,
@@ -733,7 +737,13 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertFormErrors(res, 1)
self.assertContains(res, "10 through 20")
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'network_availability_zone': 2,
+ 'subnet_allocation': 1,
+ 'provider': 2})
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
@test.update_settings(
OPENSTACK_NEUTRON_NETWORK={
@@ -741,11 +751,11 @@ class NetworkTests(test.BaseAdminViewTests):
def test_network_create_no_provider_types(self):
tenants = self.tenants.list()
- api.keystone.tenant_list(IsA(http.HttpRequest)).AndReturn([tenants,
- False])
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'network_availability_zone': False,
+ 'subnet_allocation': False,
+ 'provider': True})
url = reverse('horizon:admin:networks:create')
res = self.client.get(url)
@@ -756,18 +766,25 @@ class NetworkTests(test.BaseAdminViewTests):
'<input type="hidden" name="network_type" id="id_network_type" />',
html=True)
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'network_availability_zone': 2,
+ 'subnet_allocation': 1,
+ 'provider': 1})
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
@test.update_settings(
OPENSTACK_NEUTRON_NETWORK={
'supported_provider_types': ['local', 'flat', 'gre']})
def test_network_create_unsupported_provider_types(self):
tenants = self.tenants.list()
- api.keystone.tenant_list(IsA(http.HttpRequest)).AndReturn([tenants,
- False])
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- AndReturn(True)
- self.mox.ReplayAll()
+
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'network_availability_zone': False,
+ 'subnet_allocation': False,
+ 'provider': True})
url = reverse('horizon:admin:networks:create')
res = self.client.get(url)
@@ -778,26 +795,30 @@ class NetworkTests(test.BaseAdminViewTests):
('flat', 'Flat'),
('gre', 'GRE')])
- @test.create_stubs({api.neutron: ('network_get',)})
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'network_availability_zone': 2,
+ 'subnet_allocation': 1,
+ 'provider': 1})
+
+ @test.create_mocks({api.neutron: ('network_get',)})
def test_network_update_get(self):
network = self.networks.first()
- api.neutron.network_get(IsA(http.HttpRequest), network.id,
- expand_subnet=False).AndReturn(network)
-
- self.mox.ReplayAll()
+ self.mock_network_get.return_value = network
url = reverse('horizon:admin:networks:update', args=[network.id])
res = self.client.get(url)
self.assertTemplateUsed(res, 'admin/networks/update.html')
- @test.create_stubs({api.neutron: ('network_get',)})
+ self.mock_network_get.assert_called_once_with(test.IsHttpRequest(),
+ network.id,
+ expand_subnet=False)
+
+ @test.create_mocks({api.neutron: ('network_get',)})
def test_network_update_get_exception(self):
network = self.networks.first()
- api.neutron.network_get(IsA(http.HttpRequest), network.id)\
- .AndRaise(self.exceptions.neutron)
-
- self.mox.ReplayAll()
+ self.mock_network_get.side_effect = self.exceptions.neutron
url = reverse('horizon:admin:networks:update', args=[network.id])
res = self.client.get(url)
@@ -805,20 +826,17 @@ class NetworkTests(test.BaseAdminViewTests):
redir_url = INDEX_URL
self.assertRedirectsNoFollow(res, redir_url)
- @test.create_stubs({api.neutron: ('network_update',
+ self.mock_network_get.assert_called_once_with(test.IsHttpRequest(),
+ network.id,
+ expand_subnet=False)
+
+ @test.create_mocks({api.neutron: ('network_update',
'network_get',)})
def test_network_update_post(self):
network = self.networks.first()
- params = {'name': network.name,
- 'shared': True,
- 'admin_state_up': network.admin_state_up,
- 'router:external': True}
- api.neutron.network_update(IsA(http.HttpRequest), network.id,
- **params)\
- .AndReturn(network)
- api.neutron.network_get(IsA(http.HttpRequest), network.id,
- expand_subnet=False).AndReturn(network)
- self.mox.ReplayAll()
+
+ self.mock_network_update.return_value = network
+ self.mock_network_get.return_value = network
form_data = {'network_id': network.id,
'name': network.name,
@@ -831,7 +849,18 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('network_update',
+ params = {'name': network.name,
+ 'shared': True,
+ 'admin_state_up': network.admin_state_up,
+ 'router:external': True}
+ self.mock_network_update.assert_called_once_with(test.IsHttpRequest(),
+ network.id,
+ **params)
+ self.mock_network_get.assert_called_once_with(test.IsHttpRequest(),
+ network.id,
+ expand_subnet=False)
+
+ @test.create_mocks({api.neutron: ('network_update',
'network_get',)})
def test_network_update_post_exception(self):
network = self.networks.first()
@@ -839,12 +868,8 @@ class NetworkTests(test.BaseAdminViewTests):
'shared': False,
'admin_state_up': network.admin_state_up,
'router:external': False}
- api.neutron.network_update(IsA(http.HttpRequest), network.id,
- **params)\
- .AndRaise(self.exceptions.neutron)
- api.neutron.network_get(IsA(http.HttpRequest), network.id,
- expand_subnet=False).AndReturn(network)
- self.mox.ReplayAll()
+ self.mock_network_update.side_effect = self.exceptions.neutron
+ self.mock_network_get.return_value = network
form_data = {'network_id': network.id,
'name': network.name,
@@ -857,7 +882,14 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('network_list',
+ self.mock_network_update.assert_called_once_with(test.IsHttpRequest(),
+ network.id,
+ **params)
+ self.mock_network_get.assert_called_once_with(test.IsHttpRequest(),
+ network.id,
+ expand_subnet=False)
+
+ @test.create_mocks({api.neutron: ('network_list',
'network_delete',
'list_dhcp_agent_hosting_networks',
'is_extension_supported'),
@@ -865,32 +897,32 @@ class NetworkTests(test.BaseAdminViewTests):
def test_delete_network(self):
tenants = self.tenants.list()
network = self.networks.first()
- api.neutron.list_dhcp_agent_hosting_networks(IsA(http.HttpRequest),
- network.id).\
- AndReturn(self.agents.list())
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.keystone.tenant_list(IsA(http.HttpRequest))\
- .AndReturn([tenants, False])
- api.neutron.network_list(IsA(http.HttpRequest))\
- .AndReturn([network])
- api.neutron.network_delete(IsA(http.HttpRequest), network.id)
- self.mox.ReplayAll()
+ self.mock_list_dhcp_agent_hosting_networks.return_value = \
+ self.agents.list()
+ self._stub_is_extension_supported(
+ {'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+ self.mock_tenant_list.return_value = [tenants, False]
+ self.mock_network_list.return_value = [network]
+ self.mock_network_delete.return_value = None
form_data = {'action': 'networks__delete__%s' % network.id}
res = self.client.post(INDEX_URL, form_data)
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('network_list',
+ self.mock_list_dhcp_agent_hosting_networks.assert_called_once_with(
+ test.IsHttpRequest(), network.id)
+ self._check_is_extension_supported(
+ {'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 2})
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self.mock_network_list.assert_called_once_with(test.IsHttpRequest())
+ self.mock_network_delete.assert_called_once_with(test.IsHttpRequest(),
+ network.id)
+
+ @test.create_mocks({api.neutron: ('network_list',
'network_delete',
'list_dhcp_agent_hosting_networks',
'is_extension_supported'),
@@ -898,59 +930,55 @@ class NetworkTests(test.BaseAdminViewTests):
def test_delete_network_exception(self):
tenants = self.tenants.list()
network = self.networks.first()
- api.neutron.list_dhcp_agent_hosting_networks(IsA(http.HttpRequest),
- network.id).\
- AndReturn(self.agents.list())
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.keystone.tenant_list(IsA(http.HttpRequest))\
- .AndReturn([tenants, False])
- api.neutron.network_list(IsA(http.HttpRequest))\
- .AndReturn([network])
- api.neutron.network_delete(IsA(http.HttpRequest), network.id)\
- .AndRaise(self.exceptions.neutron)
- self.mox.ReplayAll()
+ self.mock_list_dhcp_agent_hosting_networks.return_value = \
+ self.agents.list()
+ self._stub_is_extension_supported(
+ {'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+ self.mock_tenant_list.return_value = [tenants, False]
+ self.mock_network_list.return_value = [network]
+ self.mock_network_delete.side_effect = self.exceptions.neutron
form_data = {'action': 'networks__delete__%s' % network.id}
res = self.client.post(INDEX_URL, form_data)
self.assertRedirectsNoFollow(res, INDEX_URL)
- @test.create_stubs({api.neutron: ('is_extension_supported',)})
+ self.mock_list_dhcp_agent_hosting_networks.assert_called_once_with(
+ test.IsHttpRequest(), network.id)
+ self._check_is_extension_supported(
+ {'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 2})
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self.mock_network_list.assert_called_once_with(test.IsHttpRequest())
+ self.mock_network_delete.assert_called_once_with(test.IsHttpRequest(),
+ network.id)
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',)})
@test.update_settings(FILTER_DATA_FIRST={'admin.networks': True})
def test_networks_list_with_admin_filter_first(self):
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- self.mox.ReplayAll()
+ self._stub_is_extension_supported(
+ {'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+
res = self.client.get(reverse('horizon:admin:networks:index'))
self.assertTemplateUsed(res, INDEX_TEMPLATE)
networks = res.context['networks_table'].data
self.assertItemsEqual(networks, [])
- @test.create_stubs({api.keystone: ('tenant_list',),
+ self._check_is_extension_supported(
+ {'network_availability_zone': 1,
+ 'dhcp_agent_scheduler': 1})
+
+ @test.create_mocks({api.keystone: ('tenant_list',),
api.neutron: ('is_extension_supported',)})
def test_networks_list_with_non_exist_tenant_filter(self):
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'network_availability_zone').AndReturn(True)
- api.neutron.is_extension_supported(
- IsA(http.HttpRequest),
- 'dhcp_agent_scheduler').AndReturn(True)
- api.keystone.tenant_list(IsA(http.HttpRequest))\
- .AndReturn([self.tenants.list(), False])
- self.mox.ReplayAll()
+ self._stub_is_extension_supported(
+ {'network_availability_zone': True,
+ 'dhcp_agent_scheduler': True})
+ self.mock_tenant_list.return_value = [self.tenants.list(), False]
+
self.client.post(
reverse('horizon:admin:networks:index'),
data={'networks__filter_admin_networks__q_field': 'project',
@@ -960,33 +988,44 @@ class NetworkTests(test.BaseAdminViewTests):
networks = res.context['networks_table'].data
self.assertItemsEqual(networks, [])
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self._check_is_extension_supported(
+ {'network_availability_zone': 2,
+ 'dhcp_agent_scheduler': 2})
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
def test_network_create_without_physical_networks(self):
tenants = self.tenants.list()
- api.keystone.tenant_list(IsA(http.HttpRequest)).AndReturn([tenants,
- False])
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'provider': True,
+ 'network_availability_zone': False,
+ 'subnet_allocation': False})
url = reverse('horizon:admin:networks:create')
res = self.client.get(url)
physical_network = res.context['form'].fields['physical_network']
self.assertEqual(type(physical_network), forms.CharField)
- @test.create_stubs({api.neutron: ('is_extension_supported',),
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'provider': 1,
+ 'network_availability_zone': 2,
+ 'subnet_allocation': 1})
+
+ @test.create_mocks({api.neutron: ('is_extension_supported',),
api.keystone: ('tenant_list',)})
@test.update_settings(
OPENSTACK_NEUTRON_NETWORK={
'physical_networks': ['default', 'test']})
def test_network_create_with_physical_networks(self):
tenants = self.tenants.list()
- api.keystone.tenant_list(IsA(http.HttpRequest)).AndReturn([tenants,
- False])
- api.neutron.is_extension_supported(IsA(http.HttpRequest), 'provider').\
- AndReturn(True)
- self.mox.ReplayAll()
+ self.mock_tenant_list.return_value = [tenants, False]
+ self._stub_is_extension_supported(
+ {'provider': True,
+ 'network_availability_zone': False,
+ 'subnet_allocation': False})
url = reverse('horizon:admin:networks:create')
res = self.client.get(url)
@@ -994,3 +1033,9 @@ class NetworkTests(test.BaseAdminViewTests):
self.assertEqual(type(physical_network), forms.ThemableChoiceField)
self.assertListEqual(list(physical_network.choices),
[('default', 'default'), ('test', 'test')])
+
+ self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
+ self._check_is_extension_supported(
+ {'provider': 1,
+ 'network_availability_zone': 2,
+ 'subnet_allocation': 1})