diff --git a/neutron_vpnaas_dashboard/dashboards/project/vpn/tests.py b/neutron_vpnaas_dashboard/dashboards/project/vpn/tests.py index a9f6fd7..6984d14 100644 --- a/neutron_vpnaas_dashboard/dashboards/project/vpn/tests.py +++ b/neutron_vpnaas_dashboard/dashboards/project/vpn/tests.py @@ -12,14 +12,12 @@ # License for the specific language governing permissions and limitations # under the License. -from mox3.mox import IsA - from django.core.urlresolvers import reverse -from django import http from horizon.workflows import views from openstack_dashboard import api +from openstack_dashboard.test import helpers from neutron_vpnaas_dashboard.api import vpn as api_vpn from neutron_vpnaas_dashboard.dashboards.project.vpn import workflows @@ -27,6 +25,9 @@ from neutron_vpnaas_dashboard.test import helpers as test class VPNTests(test.TestCase): + + use_mox = False + class AttributeDict(dict): def __getattr__(self, attr): return self[attr] @@ -59,56 +60,39 @@ class VPNTests(test.TestCase): UPDATEVPNCONNECTION_PATH = 'horizon:%s:vpn:update_ipsecsiteconnection' %\ DASHBOARD - def set_up_expect(self): - # retrieves vpnservices - api_vpn.vpnservice_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.vpnservices.list()) + def setup_mocks(self): + self.mock_vpnservice_list.return_value = self.vpnservices.list() + self.mock_endpointgroup_list.return_value = self.endpointgroups.list() + self.mock_ikepolicy_list.return_value = self.ikepolicies.list() + self.mock_ipsecpolicy_list.return_value = self.ipsecpolicies.list() + self.mock_ipsecsiteconnection_list.return_value = \ + self.ipsecsiteconnections.list() - # retrieves endpoint groups - api_vpn.endpointgroup_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.endpointgroups.list()) + def setup_mocks_with_exception(self): + self.mock_vpnservice_list.side_effect = self.exceptions.neutron + self.mock_endpointgroup_list.side_effect = self.exceptions.neutron + self.mock_ikepolicy_list.side_effect = self.exceptions.neutron + self.mock_ipsecpolicy_list.side_effect = self.exceptions.neutron + self.mock_ipsecsiteconnection_list.side_effect = \ + self.exceptions.neutron - # retrieves ikepolicies - api_vpn.ikepolicy_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.ikepolicies.list()) + def check_mocks(self): + self.mock_vpnservice_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_endpointgroup_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_ikepolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_ipsecpolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_ipsecsiteconnection_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) - # retrieves ipsecpolicies - api_vpn.ipsecpolicy_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.ipsecpolicies.list()) - - # retrieves ipsecsiteconnections - api_vpn.ipsecsiteconnection_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.ipsecsiteconnections.list()) - - def set_up_expect_with_exception(self): - api_vpn.vpnservice_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndRaise(self.exceptions.neutron) - api_vpn.endpointgroup_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndRaise(self.exceptions.neutron) - api_vpn.ikepolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndRaise(self.exceptions.neutron) - api_vpn.ipsecpolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndRaise(self.exceptions.neutron) - api_vpn.ipsecsiteconnection_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndRaise(self.exceptions.neutron) - - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_vpnservices(self): - self.set_up_expect() - - self.mox.ReplayAll() + self.setup_mocks() res = self.client.get(self.INDEX_URL) @@ -117,14 +101,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['table'].data), len(self.vpnservices.list())) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_endpointgroups(self): - self.set_up_expect() - - self.mox.ReplayAll() + self.setup_mocks() res = self.client.get(self.INDEX_URL + '?tab=vpntabs__endpointgroups') @@ -133,14 +116,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['endpointgroupstable_table'].data), len(self.endpointgroups.list())) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_ikepolicies(self): - self.set_up_expect() - - self.mox.ReplayAll() + self.setup_mocks() res = self.client.get(self.INDEX_URL + '?tab=vpntabs__ikepolicies') @@ -149,14 +131,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['ikepoliciestable_table'].data), len(self.ikepolicies.list())) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_ipsecpolicies(self): - self.set_up_expect() - - self.mox.ReplayAll() + self.setup_mocks() res = self.client.get(self.INDEX_URL + '?tab=vpntabs__ipsecpolicies') @@ -165,14 +146,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['ipsecpoliciestable_table'].data), len(self.ipsecpolicies.list())) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_ipsecsiteconnections(self): - self.set_up_expect() - - self.mox.ReplayAll() + self.setup_mocks() res = self.client.get( self.INDEX_URL + '?tab=vpntabs__ipsecsiteconnections') @@ -183,14 +163,13 @@ class VPNTests(test.TestCase): self.assertEqual( len(res.context['ipsecsiteconnectionstable_table'].data), len(self.ipsecsiteconnections.list())) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_exception_vpnservices(self): - self.set_up_expect_with_exception() - - self.mox.ReplayAll() + self.setup_mocks_with_exception() res = self.client.get(self.INDEX_URL) @@ -199,14 +178,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['table'].data), 0) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_exception_endpointgroups(self): - self.set_up_expect_with_exception() - - self.mox.ReplayAll() + self.setup_mocks_with_exception() res = self.client.get(self.INDEX_URL + '?tab=vpntabs__endpointgroups') @@ -215,14 +193,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['table'].data), 0) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_exception_ikepolicies(self): - self.set_up_expect_with_exception() - - self.mox.ReplayAll() + self.setup_mocks_with_exception() res = self.client.get(self.INDEX_URL + '?tab=vpntabs__ikepolicies') @@ -231,14 +208,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['table'].data), 0) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_exception_ipsecpolicies(self): - self.set_up_expect_with_exception() - - self.mox.ReplayAll() + self.setup_mocks_with_exception() res = self.client.get(self.INDEX_URL + '?tab=vpntabs__ipsecpolicies') @@ -247,14 +223,13 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['table'].data), 0) + self.check_mocks() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_list')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_list')}) def test_index_exception_ipsecsiteconnections(self): - self.set_up_expect_with_exception() - - self.mox.ReplayAll() + self.setup_mocks_with_exception() res = self.client.get( self.INDEX_URL + '?tab=vpntabs__ipsecsiteconnections') @@ -264,19 +239,16 @@ class VPNTests(test.TestCase): self.assertTemplateUsed(res, 'horizon/common/_detail_table.html') self.assertEqual(len(res.context['table'].data), 0) + self.check_mocks() - @test.create_stubs({api.neutron: ('network_list_for_tenant', - 'router_list')}) + @helpers.create_mocks({api.neutron: ('network_list_for_tenant', + 'router_list')}) def test_add_vpnservice_get(self): networks = [{'subnets': [self.subnets.first(), ]}, ] routers = self.routers.list() - api.neutron.network_list_for_tenant( - IsA(http.HttpRequest), self.tenant.id).AndReturn(networks) - api.neutron.router_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id).AndReturn(routers) - - self.mox.ReplayAll() + self.mock_network_list_for_tenant.return_value = networks + self.mock_router_list.return_value = routers res = self.client.get(reverse(self.ADDVPNSERVICE_PATH)) @@ -287,18 +259,21 @@ class VPNTests(test.TestCase): expected_objs = ['', ] self.assertQuerysetEqual(workflow.steps, expected_objs) - @test.create_stubs({api.neutron: ('router_list', - 'network_list_for_tenant'), - api_vpn: ('vpnservice_create', )}) + self.mock_network_list_for_tenant.assert_called_once_with( + helpers.IsHttpRequest(), self.tenant.id) + self.mock_router_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + + @helpers.create_mocks({api.neutron: ('router_list', + 'network_list_for_tenant'), + api_vpn: ('vpnservice_create', )}) def test_add_vpnservice_post(self): vpnservice = self.vpnservices.first() networks = [{'subnets': [self.subnets.first(), ]}, ] routers = self.routers.list() - api.neutron.network_list_for_tenant( - IsA(http.HttpRequest), self.tenant.id).AndReturn(networks) - api.neutron.router_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id).AndReturn(routers) + self.mock_network_list_for_tenant.return_value = networks + self.mock_router_list.return_value = routers form_data = {'name': vpnservice['name'], 'description': vpnservice['description'], @@ -306,29 +281,29 @@ class VPNTests(test.TestCase): 'router_id': vpnservice['router_id'], 'admin_state_up': vpnservice['admin_state_up']} - api_vpn.vpnservice_create( - IsA(http.HttpRequest), **form_data).AndReturn(vpnservice) - - self.mox.ReplayAll() + self.mock_vpnservice_create.return_value = vpnservice res = self.client.post(reverse(self.ADDVPNSERVICE_PATH), form_data) self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api.neutron: ('router_list', - 'network_list_for_tenant')}) + self.mock_network_list_for_tenant.assert_called_once_with( + helpers.IsHttpRequest(), self.tenant.id) + self.mock_router_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_vpnservice_create.assert_called_once_with( + helpers.IsHttpRequest(), **form_data) + + @helpers.create_mocks({api.neutron: ('router_list', + 'network_list_for_tenant')}) def test_add_vpnservice_post_error(self): vpnservice = self.vpnservices.first() networks = [{'subnets': [self.subnets.first(), ]}, ] routers = self.routers.list() - api.neutron.network_list_for_tenant( - IsA(http.HttpRequest), self.tenant.id).AndReturn(networks) - api.neutron.router_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id).AndReturn(routers) - - self.mox.ReplayAll() + self.mock_network_list_for_tenant.return_value = networks + self.mock_router_list.return_value = routers form_data = {'name': vpnservice['name'], 'description': vpnservice['description'], @@ -340,14 +315,16 @@ class VPNTests(test.TestCase): self.assertFormErrors(res, 1) - @test.create_stubs({api.neutron: ('network_list_for_tenant', )}) + self.mock_network_list_for_tenant.assert_called_once_with( + helpers.IsHttpRequest(), self.tenant.id) + self.mock_router_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + + @helpers.create_mocks({api.neutron: ('network_list_for_tenant', )}) def test_add_endpointgroup_get(self): networks = [{'subnets': [self.subnets.first(), ]}, ] - api.neutron.network_list_for_tenant( - IsA(http.HttpRequest), self.tenant.id).AndReturn(networks) - - self.mox.ReplayAll() + self.mock_network_list_for_tenant.return_value = networks res = self.client.get(reverse(self.ADDENDPOINTGROUP_PATH)) @@ -357,40 +334,43 @@ class VPNTests(test.TestCase): expected_objs = ['', ] self.assertQuerysetEqual(workflow.steps, expected_objs) + self.mock_network_list_for_tenant.assert_called_once_with( + helpers.IsHttpRequest(), self.tenant.id) - @test.create_stubs({api.neutron: ('network_list_for_tenant', ), - api_vpn: ('endpointgroup_create', )}) + @helpers.create_mocks({api.neutron: ('network_list_for_tenant', ), + api_vpn: ('endpointgroup_create', )}) def test_add_endpointgroup_post(self): endpointgroup = self.endpointgroups.first() networks = [{'subnets': [self.subnets.first(), ]}, ] - api.neutron.network_list_for_tenant( - IsA(http.HttpRequest), self.tenant.id).AndReturn(networks) + self.mock_network_list_for_tenant.return_value = networks form_data = {'name': endpointgroup['name'], 'description': endpointgroup['description'], - 'endpoints': endpointgroup['endpoints'], + 'subnets': endpointgroup['endpoints'], 'type': endpointgroup['type']} - api_vpn.endpointgroup_create( - IsA(http.HttpRequest), **form_data).AndReturn(endpointgroup) - - self.mox.ReplayAll() + self.mock_endpointgroup_create.return_value = endpointgroup res = self.client.post(reverse(self.ADDENDPOINTGROUP_PATH), form_data) self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api.neutron: ('network_list_for_tenant', )}) + self.mock_network_list_for_tenant.assert_called_once_with( + helpers.IsHttpRequest(), self.tenant.id) + data = form_data.copy() + data['endpoints'] = data['subnets'] + del data['subnets'] + self.mock_endpointgroup_create.assert_called_once_with( + helpers.IsHttpRequest(), **data) + + @helpers.create_mocks({api.neutron: ('network_list_for_tenant', )}) def test_add_endpointgroup_post_error(self): endpointgroup = self.endpointgroups.first() networks = [{'subnets': [self.subnets.first(), ]}, ] - api.neutron.network_list_for_tenant( - IsA(http.HttpRequest), self.tenant.id).AndReturn(networks) - - self.mox.ReplayAll() + self.mock_network_list_for_tenant.return_value = networks form_data = {'name': endpointgroup['name'], 'description': endpointgroup['description'], @@ -400,6 +380,8 @@ class VPNTests(test.TestCase): res = self.client.post(reverse(self.ADDENDPOINTGROUP_PATH), form_data) self.assertFormErrors(res, 1) + self.mock_network_list_for_tenant.assert_called_once_with( + helpers.IsHttpRequest(), self.tenant.id) def test_add_ikepolicy_get(self): res = self.client.get(reverse(self.ADDIKEPOLICY_PATH)) @@ -411,7 +393,7 @@ class VPNTests(test.TestCase): expected_objs = ['', ] self.assertQuerysetEqual(workflow.steps, expected_objs) - @test.create_stubs({api_vpn: ('ikepolicy_create', )}) + @helpers.create_mocks({api_vpn: ('ikepolicy_create', )}) def test_add_ikepolicy_post(self): ikepolicy = self.ikepolicies.first() @@ -427,15 +409,19 @@ class VPNTests(test.TestCase): 'phase1_negotiation_mode'], 'pfs': ikepolicy['pfs']} - api_vpn.ikepolicy_create( - IsA(http.HttpRequest), **form_data).AndReturn(ikepolicy) - - self.mox.ReplayAll() + self.mock_ikepolicy_create.return_value = ikepolicy res = self.client.post(reverse(self.ADDIKEPOLICY_PATH), form_data) self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) + data = form_data.copy() + data['lifetime'] = {'units': data['lifetime_units'], + 'value': data['lifetime_value']} + del data['lifetime_units'] + del data['lifetime_value'] + self.mock_ikepolicy_create.assert_called_once_with( + helpers.IsHttpRequest(), **data) def test_add_ikepolicy_post_error(self): ikepolicy = self.ikepolicies.first() @@ -466,7 +452,7 @@ class VPNTests(test.TestCase): expected_objs = ['', ] self.assertQuerysetEqual(workflow.steps, expected_objs) - @test.create_stubs({api_vpn: ('ipsecpolicy_create', )}) + @helpers.create_mocks({api_vpn: ('ipsecpolicy_create', )}) def test_add_ipsecpolicy_post(self): ipsecpolicy = self.ipsecpolicies.first() @@ -483,16 +469,21 @@ class VPNTests(test.TestCase): 'transform_protocol': ipsecpolicy[ 'transform_protocol']} - api_vpn.ipsecpolicy_create( - IsA(http.HttpRequest), **form_data).AndReturn(ipsecpolicy) - - self.mox.ReplayAll() + self.mock_ipsecpolicy_create.return_value = ipsecpolicy res = self.client.post(reverse(self.ADDIPSECPOLICY_PATH), form_data) self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) + data = form_data.copy() + data['lifetime'] = {'units': data['lifetime_units'], + 'value': data['lifetime_value']} + del data['lifetime_units'] + del data['lifetime_value'] + self.mock_ipsecpolicy_create.assert_called_once_with( + helpers.IsHttpRequest(), **data) + def test_add_ipsecpolicy_post_error(self): ipsecpolicy = self.ipsecpolicies.first() @@ -513,24 +504,18 @@ class VPNTests(test.TestCase): self.assertFormErrors(res, 1) - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list',)}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', + 'ipsecpolicy_list', + 'vpnservice_list', + 'endpointgroup_list',)}) def test_add_ipsecsiteconnection_get(self): ikepolicies = self.ikepolicies.list() ipsecpolicies = self.ipsecpolicies.list() vpnservices = self.vpnservices.list() - api_vpn.ikepolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(ikepolicies) - api_vpn.ipsecpolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(ipsecpolicies) - api_vpn.vpnservice_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(vpnservices) - - self.mox.ReplayAll() + self.mock_ikepolicy_list.return_value = ikepolicies + self.mock_ipsecpolicy_list.return_value = ipsecpolicies + self.mock_vpnservice_list.return_value = vpnservices res = self.client.get(reverse(self.ADDVPNCONNECTION_PATH)) @@ -544,15 +529,25 @@ class VPNTests(test.TestCase): 'addipsecsiteconnectionoptionalaction>', ] self.assertQuerysetEqual(workflow.steps, expected_objs) - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_create')}) + self.mock_ikepolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + self.mock_ipsecpolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + self.mock_vpnservice_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_create')}) def test_add_ipsecsiteconnection_post(self): self._test_add_ipsecsiteconnection_post() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_create')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_create')}) def test_add_ipsecsiteconnection_post_single_subnet(self): self._test_add_ipsecsiteconnection_post(subnet_list=False) @@ -565,53 +560,67 @@ class VPNTests(test.TestCase): ipsecpolicies = self.ipsecpolicies.list() vpnservices = self.vpnservices.list() - api_vpn.ikepolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(ikepolicies) - api_vpn.ipsecpolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(ipsecpolicies) - api_vpn.vpnservice_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(vpnservices) + form_data = { + 'name': ipsecsiteconnection['name'], + 'description': ipsecsiteconnection['description'], + 'dpd_action': ipsecsiteconnection['dpd']['action'], + 'dpd_interval': ipsecsiteconnection['dpd']['interval'], + 'dpd_timeout': ipsecsiteconnection['dpd']['timeout'], + 'ikepolicy_id': ipsecsiteconnection['ikepolicy_id'], + 'initiator': ipsecsiteconnection['initiator'], + 'ipsecpolicy_id': ipsecsiteconnection['ipsecpolicy_id'], + 'mtu': ipsecsiteconnection['mtu'], + 'peer_address': ipsecsiteconnection['peer_address'], + 'peer_cidrs': ', '.join(ipsecsiteconnection['peer_cidrs']), + 'peer_id': ipsecsiteconnection['peer_id'], + 'psk': ipsecsiteconnection['psk'], + 'vpnservice_id': ipsecsiteconnection['vpnservice_id'], + 'admin_state_up': ipsecsiteconnection['admin_state_up'], + } - form_data = {'name': ipsecsiteconnection['name'], - 'description': ipsecsiteconnection['description'], - 'dpd_action': ipsecsiteconnection['dpd']['action'], - 'dpd_interval': ipsecsiteconnection['dpd']['interval'], - 'dpd_timeout': ipsecsiteconnection['dpd']['timeout'], - 'ikepolicy_id': ipsecsiteconnection['ikepolicy_id'], - 'initiator': ipsecsiteconnection['initiator'], - 'ipsecpolicy_id': ipsecsiteconnection[ - 'ipsecpolicy_id'], - 'mtu': ipsecsiteconnection['mtu'], - 'peer_address': ipsecsiteconnection['peer_address'], - 'peer_cidrs': ipsecsiteconnection['peer_cidrs'], - 'peer_id': ipsecsiteconnection['peer_id'], - 'psk': ipsecsiteconnection['psk'], - 'vpnservice_id': ipsecsiteconnection['vpnservice_id'], - 'admin_state_up': ipsecsiteconnection[ - 'admin_state_up']} - - api_vpn.ipsecsiteconnection_create( - IsA(http.HttpRequest), **form_data).AndReturn(ipsecsiteconnection) - - self.mox.ReplayAll() + self.mock_ikepolicy_list.return_value = ikepolicies + self.mock_ipsecpolicy_list.return_value = ipsecpolicies + self.mock_vpnservice_list.return_value = vpnservices + self.mock_ipsecsiteconnection_create.return_value = ipsecsiteconnection res = self.client.post(reverse(self.ADDVPNCONNECTION_PATH), form_data) self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_create')}) + self.mock_ikepolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + self.mock_ipsecpolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + self.mock_vpnservice_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + + data = form_data.copy() + data['peer_cidrs'] = ipsecsiteconnection['peer_cidrs'] + data['dpd'] = {'action': data['dpd_action'], + 'interval': data['dpd_interval'], + 'timeout': data['dpd_timeout']} + del data['dpd_action'] + del data['dpd_interval'] + del data['dpd_timeout'] + data['local_ep_group_id'] = '' + data['peer_ep_group_id'] = '' + + self.mock_ipsecsiteconnection_create.assert_called_once_with( + helpers.IsHttpRequest(), **data) + + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_create')}) def test_add_ipsecsiteconnection_post_required_fields_error(self): self._test_add_ipsecsiteconnection_post_error() - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', - 'vpnservice_list', 'endpointgroup_list', - 'ipsecsiteconnection_create')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ipsecpolicy_list', + 'vpnservice_list', 'endpointgroup_list', + 'ipsecsiteconnection_create')}) def test_add_ipsecsiteconnection_post_peer_cidrs_error(self): self._test_add_ipsecsiteconnection_post_error(subnets=True) @@ -621,17 +630,9 @@ class VPNTests(test.TestCase): ipsecpolicies = self.ipsecpolicies.list() vpnservices = self.vpnservices.list() - api_vpn.ikepolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(ikepolicies) - api_vpn.ipsecpolicy_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(ipsecpolicies) - api_vpn.vpnservice_list( - IsA(http.HttpRequest), - tenant_id=self.tenant.id).AndReturn(vpnservices) - - self.mox.ReplayAll() + self.mock_ikepolicy_list.return_value = ikepolicies + self.mock_ipsecpolicy_list.return_value = ipsecpolicies + self.mock_vpnservice_list.return_value = vpnservices form_data = {'name': '', 'description': ipsecsiteconnection['description'], @@ -659,14 +660,21 @@ class VPNTests(test.TestCase): else: self.assertFormErrors(res, 6) - @test.create_stubs({api_vpn: ('vpnservice_get', )}) + self.mock_ikepolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + self.mock_ipsecpolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + self.mock_vpnservice_list.assert_called_once_with( + helpers.IsHttpRequest(), + tenant_id=self.tenant.id) + + @helpers.create_mocks({api_vpn: ('vpnservice_get', )}) def test_update_vpnservice_get(self): vpnservice = self.vpnservices.first() - api_vpn.vpnservice_get(IsA(http.HttpRequest), vpnservice.id)\ - .AndReturn(vpnservice) - - self.mox.ReplayAll() + self.mock_vpnservice_get.return_value = vpnservice res = self.client.get( reverse(self.UPDATEVPNSERVICE_PATH, args=(vpnservice.id,))) @@ -674,21 +682,20 @@ class VPNTests(test.TestCase): self.assertTemplateUsed( res, 'project/vpn/update_vpnservice.html') - @test.create_stubs({api_vpn: ('vpnservice_get', 'vpnservice_update')}) + self.mock_vpnservice_get.assert_called_once_with( + helpers.IsHttpRequest(), vpnservice.id) + + @helpers.create_mocks({api_vpn: ('vpnservice_get', 'vpnservice_update')}) def test_update_vpnservice_post(self): vpnservice = self.vpnservices.first() - api_vpn.vpnservice_get(IsA(http.HttpRequest), vpnservice.id)\ - .AndReturn(vpnservice) + self.mock_vpnservice_get.return_value = vpnservice data = {'name': vpnservice.name, 'description': vpnservice.description, 'admin_state_up': vpnservice.admin_state_up} - api_vpn.vpnservice_update(IsA(http.HttpRequest), vpnservice.id, - vpnservice=data).AndReturn(vpnservice) - - self.mox.ReplayAll() + self.mock_vpnservice_update.return_value = vpnservice form_data = data.copy() form_data['vpnservice_id'] = vpnservice.id @@ -699,14 +706,16 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api_vpn: ('endpointgroup_get', )}) + self.mock_vpnservice_get.assert_called_once_with( + helpers.IsHttpRequest(), vpnservice.id) + self.mock_vpnservice_update.assert_called_once_with( + helpers.IsHttpRequest(), vpnservice.id, vpnservice=data) + + @helpers.create_mocks({api_vpn: ('endpointgroup_get', )}) def test_update_endpointgroup_get(self): endpointgroup = self.endpointgroups.first() - api_vpn.endpointgroup_get(IsA(http.HttpRequest), endpointgroup.id)\ - .AndReturn(endpointgroup) - - self.mox.ReplayAll() + self.mock_endpointgroup_get.return_value = endpointgroup res = self.client.get( reverse(self.UPDATEENDPOINTGROUP_PATH, args=(endpointgroup.id,))) @@ -714,22 +723,19 @@ class VPNTests(test.TestCase): self.assertTemplateUsed( res, 'project/vpn/update_endpointgroup.html') - @test.create_stubs({api_vpn: ('endpointgroup_get', - 'endpointgroup_update')}) + self.mock_endpointgroup_get.assert_called_once_with( + helpers.IsHttpRequest(), endpointgroup.id) + + @helpers.create_mocks({api_vpn: ('endpointgroup_get', + 'endpointgroup_update')}) def test_update_endpointgroup_post(self): endpointgroup = self.endpointgroups.first() - api_vpn.endpointgroup_get(IsA(http.HttpRequest), endpointgroup.id)\ - .AndReturn(endpointgroup) - data = {'name': endpointgroup.name, 'description': endpointgroup.description} - api_vpn.endpointgroup_update(IsA(http.HttpRequest), endpointgroup.id, - endpointgroup=data - ).AndReturn(endpointgroup) - - self.mox.ReplayAll() + self.mock_endpointgroup_get.return_value = endpointgroup + self.mock_endpointgroup_update.return_value = endpointgroup form_data = data.copy() form_data['endpoint_group_id'] = endpointgroup.id @@ -741,28 +747,29 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api_vpn: ('ikepolicy_get', )}) + self.mock_endpointgroup_get.assert_called_once_with( + helpers.IsHttpRequest(), endpointgroup.id) + self.mock_endpointgroup_update.assert_called_once_with( + helpers.IsHttpRequest(), endpointgroup.id, endpoint_group=data) + + @helpers.create_mocks({api_vpn: ('ikepolicy_get', )}) def test_update_ikepolicy_get(self): ikepolicy = self.ikepolicies.first() - api_vpn.ikepolicy_get(IsA(http.HttpRequest), ikepolicy.id)\ - .AndReturn(ikepolicy) - - self.mox.ReplayAll() + self.mock_ikepolicy_get.return_value = ikepolicy res = self.client.get( reverse(self.UPDATEIKEPOLICY_PATH, args=(ikepolicy.id,))) self.assertTemplateUsed( res, 'project/vpn/update_ikepolicy.html') + self.mock_ikepolicy_get.assert_called_once_with( + helpers.IsHttpRequest(), ikepolicy.id) - @test.create_stubs({api_vpn: ('ikepolicy_get', 'ikepolicy_update')}) + @helpers.create_mocks({api_vpn: ('ikepolicy_get', 'ikepolicy_update')}) def test_update_ikepolicy_post(self): ikepolicy = self.ikepolicies.first() - api_vpn.ikepolicy_get(IsA(http.HttpRequest), ikepolicy.id)\ - .AndReturn(ikepolicy) - data = {'name': ikepolicy.name, 'description': ikepolicy.description, 'auth_algorithm': ikepolicy.auth_algorithm, @@ -772,10 +779,8 @@ class VPNTests(test.TestCase): 'pfs': ikepolicy.pfs, 'phase1_negotiation_mode': ikepolicy.phase1_negotiation_mode} - api_vpn.ikepolicy_update(IsA(http.HttpRequest), ikepolicy.id, - ikepolicy=data).AndReturn(ikepolicy) - - self.mox.ReplayAll() + self.mock_ikepolicy_get.return_value = ikepolicy + self.mock_ikepolicy_update.return_value = ikepolicy form_data = data.copy() @@ -790,14 +795,16 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api_vpn: ('ipsecpolicy_get', )}) + self.mock_ikepolicy_get.assert_called_once_with( + helpers.IsHttpRequest(), ikepolicy.id) + self.mock_ikepolicy_update.assert_called_once_with( + helpers.IsHttpRequest(), ikepolicy.id, ikepolicy=data) + + @helpers.create_mocks({api_vpn: ('ipsecpolicy_get', )}) def test_update_ipsecpolicy_get(self): ipsecpolicy = self.ipsecpolicies.first() - api_vpn.ipsecpolicy_get(IsA(http.HttpRequest), ipsecpolicy.id)\ - .AndReturn(ipsecpolicy) - - self.mox.ReplayAll() + self.mock_ipsecpolicy_get.return_value = ipsecpolicy res = self.client.get( reverse(self.UPDATEIPSECPOLICY_PATH, args=(ipsecpolicy.id,))) @@ -805,12 +812,14 @@ class VPNTests(test.TestCase): self.assertTemplateUsed( res, 'project/vpn/update_ipsecpolicy.html') - @test.create_stubs({api_vpn: ('ipsecpolicy_get', 'ipsecpolicy_update')}) + self.mock_ipsecpolicy_get.assert_called_once_with( + helpers.IsHttpRequest(), ipsecpolicy.id) + + @helpers.create_mocks({api_vpn: ('ipsecpolicy_get', 'ipsecpolicy_update')}) def test_update_ipsecpolicy_post(self): ipsecpolicy = self.ipsecpolicies.first() - api_vpn.ipsecpolicy_get(IsA(http.HttpRequest), ipsecpolicy.id)\ - .AndReturn(ipsecpolicy) + self.mock_ipsecpolicy_get.return_value = ipsecpolicy data = {'name': ipsecpolicy.name, 'description': ipsecpolicy.description, @@ -821,10 +830,7 @@ class VPNTests(test.TestCase): 'pfs': ipsecpolicy.pfs, 'transform_protocol': ipsecpolicy.transform_protocol} - api_vpn.ipsecpolicy_update(IsA(http.HttpRequest), ipsecpolicy.id, - ipsecpolicy=data).AndReturn(ipsecpolicy) - - self.mox.ReplayAll() + self.mock_ipsecpolicy_update.return_value = ipsecpolicy form_data = data.copy() @@ -839,15 +845,16 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api_vpn: ('ipsecsiteconnection_get', )}) + self.mock_ipsecpolicy_get.assert_called_once_with( + helpers.IsHttpRequest(), ipsecpolicy.id) + self.mock_ipsecpolicy_update.assert_called_once_with( + helpers.IsHttpRequest(), ipsecpolicy.id, ipsecpolicy=data) + + @helpers.create_mocks({api_vpn: ('ipsecsiteconnection_get', )}) def test_update_ipsecsiteconnection_get(self): ipsecsiteconnection = self.ipsecsiteconnections.first() - api_vpn.ipsecsiteconnection_get( - IsA(http.HttpRequest), ipsecsiteconnection.id)\ - .AndReturn(ipsecsiteconnection) - - self.mox.ReplayAll() + self.mock_ipsecsiteconnection_get.return_value = ipsecsiteconnection res = self.client.get( reverse(self.UPDATEVPNCONNECTION_PATH, @@ -855,15 +862,15 @@ class VPNTests(test.TestCase): self.assertTemplateUsed( res, 'project/vpn/update_ipsecsiteconnection.html') + self.mock_ipsecsiteconnection_get.assert_called_once_with( + helpers.IsHttpRequest(), ipsecsiteconnection.id) - @test.create_stubs({api_vpn: ('ipsecsiteconnection_get', - 'ipsecsiteconnection_update')}) + @helpers.create_mocks({api_vpn: ('ipsecsiteconnection_get', + 'ipsecsiteconnection_update')}) def test_update_ipsecsiteconnection_post(self): ipsecsiteconnection = self.ipsecsiteconnections.first() - api_vpn.ipsecsiteconnection_get( - IsA(http.HttpRequest), ipsecsiteconnection.id)\ - .AndReturn(ipsecsiteconnection) + self.mock_ipsecsiteconnection_get.return_value = ipsecsiteconnection data = {'name': ipsecsiteconnection.name, 'description': ipsecsiteconnection.description, @@ -876,11 +883,7 @@ class VPNTests(test.TestCase): 'initiator': ipsecsiteconnection.initiator, 'admin_state_up': ipsecsiteconnection.admin_state_up} - api_vpn.ipsecsiteconnection_update( - IsA(http.HttpRequest), ipsecsiteconnection.id, - ipsec_site_connection=data).AndReturn(ipsecsiteconnection) - - self.mox.ReplayAll() + self.mock_ipsecsiteconnection_update.return_value = ipsecsiteconnection form_data = data.copy() @@ -900,14 +903,17 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) self.assertRedirectsNoFollow(res, str(self.INDEX_URL)) - @test.create_stubs({api_vpn: ('vpnservice_list', 'vpnservice_delete',)}) + self.mock_ipsecsiteconnection_get.assert_called_once_with( + helpers.IsHttpRequest(), ipsecsiteconnection.id) + self.mock_ipsecsiteconnection_update.assert_called_once_with( + helpers.IsHttpRequest(), ipsecsiteconnection.id, + ipsec_site_connection=data) + + @helpers.create_mocks({api_vpn: ('vpnservice_list', 'vpnservice_delete',)}) def test_delete_vpnservice(self): vpnservice = self.vpnservices.list()[1] - api_vpn.vpnservice_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.vpnservices.list()) - api_vpn.vpnservice_delete(IsA(http.HttpRequest), vpnservice.id) - self.mox.ReplayAll() + self.mock_vpnservice_list.return_value = self.vpnservices.list() + self.mock_vpnservice_delete.return_value = None form_data = {"action": "vpnservicestable__deletevpnservice__%s" % vpnservice.id} @@ -915,15 +921,17 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) - @test.create_stubs({api_vpn: ('endpointgroup_list', - 'endpointgroup_delete',)}) + self.mock_vpnservice_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_vpnservice_delete.assert_called_once_with( + helpers.IsHttpRequest(), vpnservice.id) + + @helpers.create_mocks({api_vpn: ('endpointgroup_list', + 'endpointgroup_delete',)}) def test_delete_endpointgroup(self): endpointgroup = self.endpointgroups.list()[0] - api_vpn.endpointgroup_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.endpointgroups.list()) - api_vpn.endpointgroup_delete(IsA(http.HttpRequest), endpointgroup.id) - self.mox.ReplayAll() + self.mock_endpointgroup_list.return_value = self.endpointgroups.list() + self.mock_endpointgroup_delete.return_value = None form_data = {"action": "endpointgroupstable__deleteendpointgroup__%s" @@ -932,14 +940,16 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) - @test.create_stubs({api_vpn: ('ikepolicy_list', 'ikepolicy_delete',)}) + self.mock_endpointgroup_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_endpointgroup_delete.assert_called_once_with( + helpers.IsHttpRequest(), endpointgroup.id) + + @helpers.create_mocks({api_vpn: ('ikepolicy_list', 'ikepolicy_delete',)}) def test_delete_ikepolicy(self): ikepolicy = self.ikepolicies.list()[1] - api_vpn.ikepolicy_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.ikepolicies.list()) - api_vpn.ikepolicy_delete(IsA(http.HttpRequest), ikepolicy.id) - self.mox.ReplayAll() + self.mock_ikepolicy_list.return_value = self.ikepolicies.list() + self.mock_ikepolicy_delete.return_value = None form_data = {"action": "ikepoliciestable__deleteikepolicy__%s" % ikepolicy.id} @@ -947,14 +957,17 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) - @test.create_stubs({api_vpn: ('ipsecpolicy_list', 'ipsecpolicy_delete',)}) + self.mock_ikepolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_ikepolicy_delete.assert_called_once_with( + helpers.IsHttpRequest(), ikepolicy.id) + + @helpers.create_mocks({api_vpn: ('ipsecpolicy_list', + 'ipsecpolicy_delete',)}) def test_delete_ipsecpolicy(self): ipsecpolicy = self.ipsecpolicies.list()[1] - api_vpn.ipsecpolicy_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.ipsecpolicies.list()) - api_vpn.ipsecpolicy_delete(IsA(http.HttpRequest), ipsecpolicy.id) - self.mox.ReplayAll() + self.mock_ipsecpolicy_list.return_value = self.ipsecpolicies.list() + self.mock_ipsecpolicy_delete.return_value = None form_data = {"action": "ipsecpoliciestable__deleteipsecpolicy__%s" @@ -963,16 +976,18 @@ class VPNTests(test.TestCase): self.assertNoFormErrors(res) - @test.create_stubs({api_vpn: ('ipsecsiteconnection_list', - 'ipsecsiteconnection_delete',)}) + self.mock_ipsecpolicy_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_ipsecpolicy_delete.assert_called_once_with( + helpers.IsHttpRequest(), ipsecpolicy.id) + + @helpers.create_mocks({api_vpn: ('ipsecsiteconnection_list', + 'ipsecsiteconnection_delete',)}) def test_delete_ipsecsiteconnection(self): ipsecsiteconnection = self.ipsecsiteconnections.first() - api_vpn.ipsecsiteconnection_list( - IsA(http.HttpRequest), tenant_id=self.tenant.id) \ - .AndReturn(self.ipsecsiteconnections.list()) - api_vpn.ipsecsiteconnection_delete( - IsA(http.HttpRequest), ipsecsiteconnection.id) - self.mox.ReplayAll() + self.mock_ipsecsiteconnection_list.return_value = \ + self.ipsecsiteconnections.list() + self.mock_ipsecsiteconnection_delete.return_value = None form_data = {"action": "ipsecsiteconnectionstable__deleteipsecsiteconnection__%s" @@ -980,3 +995,8 @@ class VPNTests(test.TestCase): res = self.client.post(self.INDEX_URL, form_data) self.assertNoFormErrors(res) + + self.mock_ipsecsiteconnection_list.assert_called_once_with( + helpers.IsHttpRequest(), tenant_id=self.tenant.id) + self.mock_ipsecsiteconnection_delete.assert_called_once_with( + helpers.IsHttpRequest(), ipsecsiteconnection.id) diff --git a/neutron_vpnaas_dashboard/dashboards/project/vpn/workflows.py b/neutron_vpnaas_dashboard/dashboards/project/vpn/workflows.py index 3c2508a..36cf298 100644 --- a/neutron_vpnaas_dashboard/dashboards/project/vpn/workflows.py +++ b/neutron_vpnaas_dashboard/dashboards/project/vpn/workflows.py @@ -209,7 +209,11 @@ class AddEndpointGroup(workflows.Workflow): def handle(self, request, context): try: - api_vpn.endpointgroup_create(request, **context) + api_vpn.endpointgroup_create(request, + name=context['name'], + description=context['description'], + type=context['type'], + endpoints=context['endpoints']) return True except Exception: return False