diff options
author | Cao Xuan Hoang <hoangcx@vn.fujitsu.com> | 2017-03-02 10:46:29 +0700 |
---|---|---|
committer | Cao Xuan Hoang <hoangcx@vn.fujitsu.com> | 2018-01-15 09:44:03 +0700 |
commit | dd044bd92e8b7ab41aba47488d437e771a2e1339 (patch) | |
tree | 617ced4a6e0e47dbc6a446d5e4425ff99af0b384 /neutronclient/tests/unit/osc/v2/vpnaas | |
parent | 0ce9051b3853acf881e0bd4e63aa8a1b2f46688c (diff) | |
download | python-neutronclient-dd044bd92e8b7ab41aba47488d437e771a2e1339.tar.gz |
Add VPNaaS commands for OSC plugin
Closes-Bug: 1669252
Change-Id: I447f5c50725fc0d9d8a1574ad5e28772f472fba9
Diffstat (limited to 'neutronclient/tests/unit/osc/v2/vpnaas')
7 files changed, 1884 insertions, 0 deletions
diff --git a/neutronclient/tests/unit/osc/v2/vpnaas/common.py b/neutronclient/tests/unit/osc/v2/vpnaas/common.py new file mode 100644 index 0000000..4edee8b --- /dev/null +++ b/neutronclient/tests/unit/osc/v2/vpnaas/common.py @@ -0,0 +1,157 @@ +# Copyright 2017 FUJITSU LIMITED +# All Rights Reserved +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import testtools + +from osc_lib import exceptions + +from neutronclient.tests.unit.osc.v2 import fakes as test_fakes + + +class TestCreateVPNaaS(test_fakes.TestNeutronClientOSCV2): + pass + + +class TestDeleteVPNaaS(test_fakes.TestNeutronClientOSCV2): + + def test_delete_with_one_resource(self): + target = self.resource['id'] + arglist = [target] + verifylist = [(self.res, [target])] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with(target) + self.assertIsNone(result) + + def test_delete_with_multiple_resources(self): + + def _mock_vpnaas(*args, **kwargs): + self.assertEqual(self.res, args[0]) + self.assertIsNotNone(args[1]) + self.assertEqual({'cmd_resource': self.res}, kwargs) + return {'id': args[1]} + + self.neutronclient.find_resource.side_effect = _mock_vpnaas + + target1 = 'target1' + target2 = 'target2' + arglist = [target1, target2] + verifylist = [(self.res, [target1, target2])] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + self.assertIsNone(result) + + self.assertEqual(2, self.mocked.call_count) + for idx, reference in enumerate([target1, target2]): + actual = ''.join(self.mocked.call_args_list[idx][0]) + self.assertEqual(reference, actual) + + def test_delete_multiple_with_exception(self): + target1 = 'target' + arglist = [target1] + verifylist = [(self.res, [target1])] + + self.neutronclient.find_resource.side_effect = [ + target1, exceptions.CommandError + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + resource_name = self.res.replace('_', ' ') + msg = "1 of 2 %s(s) failed to delete." % resource_name + with testtools.ExpectedException(exceptions.CommandError) as e: + self.cmd.take_action(parsed_args) + self.assertEqual(msg, str(e)) + + +class TestListVPNaaS(test_fakes.TestNeutronClientOSCV2): + + def test_list_with_no_option(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.list_headers), headers) + self.assertEqual([self.list_data], list(data)) + + def test_list_with_long_option(self): + arglist = ['--long'] + verifylist = [('long', True)] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.headers), headers) + self.assertEqual([self.data], list(data)) + + +class TestSetVPNaaS(test_fakes.TestNeutronClientOSCV2): + + def test_set_name(self): + target = self.resource['id'] + update = 'change' + arglist = [target, '--name', update] + verifylist = [ + (self.res, target), + ('name', update), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with( + target, {self.res: {'name': update}}) + self.assertIsNone(result) + + def test_set_description(self): + target = self.resource['id'] + update = 'change-desc' + arglist = [target, '--description', update] + verifylist = [ + (self.res, target), + ('description', update), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with( + target, {self.res: {'description': update}}) + self.assertIsNone(result) + + +class TestShowVPNaaS(test_fakes.TestNeutronClientOSCV2): + + def test_show_filtered_by_id_or_name(self): + target = self.resource['id'] + + def _mock_vpnaas(*args, **kwargs): + if self.neutronclient.find_resource.call_count == 1: + self.assertEqual(self.res, args[0]) + self.assertEqual(self.resource['id'], args[1]) + self.assertEqual({'cmd_resource': self.res}, kwargs) + return {'id': args[1]} + + self.neutronclient.find_resource.side_effect = _mock_vpnaas + + arglist = [target] + verifylist = [(self.res, target)] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with(target) + self.assertEqual(self.ordered_headers, headers) + self.assertItemEqual(self.ordered_data, data) diff --git a/neutronclient/tests/unit/osc/v2/vpnaas/fakes.py b/neutronclient/tests/unit/osc/v2/vpnaas/fakes.py new file mode 100644 index 0000000..7ee7c5d --- /dev/null +++ b/neutronclient/tests/unit/osc/v2/vpnaas/fakes.py @@ -0,0 +1,178 @@ +# Copyright 2017 FUJITSU LIMITED +# All Rights Reserved +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import collections +import copy +import uuid + +import mock + + +class FakeVPNaaS(object): + + def create(self, attrs={}): + """Create a fake vpnaas resources + + :param Dictionary attrs: + A dictionary with all attributes + :return: + A OrderedDict faking the vpnaas resource + """ + self.ordered.update(attrs) + return copy.deepcopy(self.ordered) + + def bulk_create(self, attrs=None, count=2): + """Create multiple fake vpnaas resources + + :param Dictionary attrs: + A dictionary with all attributes + :param int count: + The number of vpnaas resources to fake + :return: + A list of dictionaries faking the vpnaas resources + """ + return [self.create(attrs=attrs) for i in range(0, count)] + + def get(self, attrs=None, count=2): + """Get multiple fake vpnaas resources + + :param Dictionary attrs: + A dictionary with all attributes + :param int count: + The number of vpnaas resources to fake + :return: + A list of dictionaries faking the vpnaas resource + """ + if attrs is None: + self.attrs = self.bulk_create(count=count) + return mock.Mock(side_effect=attrs) + + +class IKEPolicy(FakeVPNaaS): + """Fake one or more IKE policies""" + + def __init__(self): + super(IKEPolicy, self).__init__() + self.ordered = collections.OrderedDict(( + ('id', 'ikepolicy-id-' + uuid.uuid4().hex), + ('name', 'my-ikepolicy-' + uuid.uuid4().hex), + ('auth_algorithm', 'sha1'), + ('encryption_algorithm', 'aes-128'), + ('ike_version', 'v1'), + ('pfs', 'group5'), + ('description', 'my-desc-' + uuid.uuid4().hex), + ('phase1_negotiation_mode', 'main'), + ('tenant_id', 'tenant-id-' + uuid.uuid4().hex), + ('lifetime', {'units': 'seconds', 'value': 3600}), + )) + + +class IPSecPolicy(FakeVPNaaS): + """Fake one or more IPsec policies""" + + def __init__(self): + super(IPSecPolicy, self).__init__() + self.ordered = collections.OrderedDict(( + ('id', 'ikepolicy-id-' + uuid.uuid4().hex), + ('name', 'my-ikepolicy-' + uuid.uuid4().hex), + ('auth_algorithm', 'sha1'), + ('encapsulation_mode', 'tunnel'), + ('transform_protocol', 'esp'), + ('encryption_algorithm', 'aes-128'), + ('pfs', 'group5'), + ('description', 'my-desc-' + uuid.uuid4().hex), + ('tenant_id', 'tenant-id-' + uuid.uuid4().hex), + ('lifetime', {'units': 'seconds', 'value': 3600}), + )) + + +class VPNService(FakeVPNaaS): + """Fake one or more VPN services""" + + def __init__(self): + super(VPNService, self).__init__() + self.ordered = collections.OrderedDict(( + ('id', 'vpnservice-id-' + uuid.uuid4().hex), + ('name', 'my-vpnservice-' + uuid.uuid4().hex), + ('router_id', 'router-id-' + uuid.uuid4().hex), + ('subnet_id', 'subnet-id-' + uuid.uuid4().hex), + ('flavor_id', 'flavor-id-' + uuid.uuid4().hex), + ('admin_state_up', True), + ('status', 'ACTIVE'), + ('description', 'my-desc-' + uuid.uuid4().hex), + ('tenant_id', 'tenant-id-' + uuid.uuid4().hex), + )) + + +class EndpointGroup(FakeVPNaaS): + """Fake one or more Endpoint Groups""" + + def __init__(self): + super(EndpointGroup, self).__init__() + self.ordered = collections.OrderedDict(( + ('id', 'ep-group-id-' + uuid.uuid4().hex), + ('name', 'my-ep-group-' + uuid.uuid4().hex), + ('type', 'cidr'), + ('endpoints', ['10.0.0.0/24', '20.0.0.0/24']), + ('description', 'my-desc-' + uuid.uuid4().hex), + ('tenant_id', 'tenant-id-' + uuid.uuid4().hex), + )) + + +class IPsecSiteConnection(object): + """Fake one or more IPsec site connections""" + @staticmethod + def create_conn(attrs=None): + """Create a fake IPsec conn. + + :param Dictionary attrs: + A dictionary with all attributes + :return: + A Dictionary with id, name, peer_address, auth_mode, status, + tenant_id, peer_cidrs, vpnservice_id, ipsecpolicy_id, + ikepolicy_id, mtu, initiator, admin_state_up, description, + psk, route_mode, local_id, peer_id, local_ep_group_id, + peer_ep_group_id + """ + attrs = attrs or {} + + # Set default attributes. + conn_attrs = { + 'id': 'ipsec-site-conn-id-' + uuid.uuid4().hex, + 'name': 'my-ipsec-site-conn-' + uuid.uuid4().hex, + 'peer_address': '192.168.2.10', + 'auth_mode': '', + 'status': '', + 'tenant_id': 'tenant-id-' + uuid.uuid4().hex, + 'peer_cidrs': [], + 'vpnservice_id': 'vpnservice-id-' + uuid.uuid4().hex, + 'ipsecpolicy_id': 'ipsecpolicy-id-' + uuid.uuid4().hex, + 'ikepolicy_id': 'ikepolicy-id-' + uuid.uuid4().hex, + 'mtu': 1500, + 'initiator': 'bi-directional', + 'admin_state_up': True, + 'description': 'my-vpn-connection', + 'psk': 'abcd', + 'route_mode': '', + 'local_id': '', + 'peer_id': '192.168.2.10', + 'local_ep_group_id': 'local-ep-group-id-' + uuid.uuid4().hex, + 'peer_ep_group_id': 'peer-ep-group-id-' + uuid.uuid4().hex, + } + + # Overwrite default attributes. + conn_attrs.update(attrs) + return copy.deepcopy(conn_attrs) diff --git a/neutronclient/tests/unit/osc/v2/vpnaas/test_endpoint_group.py b/neutronclient/tests/unit/osc/v2/vpnaas/test_endpoint_group.py new file mode 100644 index 0000000..cc597e7 --- /dev/null +++ b/neutronclient/tests/unit/osc/v2/vpnaas/test_endpoint_group.py @@ -0,0 +1,257 @@ +# Copyright 2017 FUJITSU LIMITED +# All Rights Reserved +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import copy + +import mock +from osc_lib.tests import utils as tests_utils + +from neutronclient.osc import utils as osc_utils +from neutronclient.osc.v2.vpnaas import endpoint_group +from neutronclient.tests.unit.osc.v2 import fakes as test_fakes +from neutronclient.tests.unit.osc.v2.vpnaas import common +from neutronclient.tests.unit.osc.v2.vpnaas import fakes + + +_endpoint_group = fakes.EndpointGroup().create() +CONVERT_MAP = { + 'project': 'tenant_id', +} + + +def _generate_data(ordered_dict=None, data=None): + source = ordered_dict if ordered_dict else _endpoint_group + if data: + source.update(data) + return tuple(source[key] for key in source) + + +def _generate_req_and_res(verifylist): + request = dict(verifylist) + response = copy.deepcopy(_endpoint_group) + for key, val in verifylist: + converted = CONVERT_MAP.get(key, key) + del request[key] + new_value = val + request[converted] = new_value + response[converted] = new_value + return request, response + + +class TestEndpointGroup(test_fakes.TestNeutronClientOSCV2): + + def check_results(self, headers, data, exp_req, is_list=False): + if is_list: + req_body = {self.res_plural: [exp_req]} + else: + req_body = {self.res: exp_req} + self.mocked.assert_called_once_with(req_body) + self.assertEqual(self.ordered_headers, headers) + self.assertEqual(self.ordered_data, data) + + def setUp(self): + super(TestEndpointGroup, self).setUp() + + def _mock_endpoint_group(*args, **kwargs): + self.neutronclient.find_resource.assert_called_once_with( + self.res, self.resource['id'], cmd_resource='endpoint_group') + return {'id': args[1]} + + self.neutronclient.find_resource.side_effect = mock.Mock( + side_effect=_mock_endpoint_group) + osc_utils.find_project = mock.Mock() + osc_utils.find_project.id = _endpoint_group['tenant_id'] + self.res = 'endpoint_group' + self.res_plural = 'endpoint_groups' + self.resource = _endpoint_group + self.headers = ( + 'ID', + 'Name', + 'Type', + 'Endpoints', + 'Description', + 'Project', + ) + self.data = _generate_data() + self.ordered_headers = ( + 'Description', + 'Endpoints', + 'ID', + 'Name', + 'Project', + 'Type', + ) + self.ordered_data = ( + _endpoint_group['description'], + _endpoint_group['endpoints'], + _endpoint_group['id'], + _endpoint_group['name'], + _endpoint_group['tenant_id'], + _endpoint_group['type'], + ) + self.ordered_columns = ( + 'description', + 'endpoints', + 'id', + 'name', + 'tenant_id', + 'type', + ) + + +class TestCreateEndpointGroup(TestEndpointGroup, common.TestCreateVPNaaS): + + def setUp(self): + super(TestCreateEndpointGroup, self).setUp() + self.neutronclient.create_endpoint_group = mock.Mock( + return_value={self.res: _endpoint_group}) + self.mocked = self.neutronclient.create_endpoint_group + self.cmd = endpoint_group.CreateEndpointGroup(self.app, self.namespace) + + def _update_expect_response(self, request, response): + """Set expected request and response + + :param request + A dictionary of request body(dict of verifylist) + :param response + A OrderedDict of request body + """ + # Update response body + self.neutronclient.create_endpoint_group.return_value = \ + {self.res: dict(response)} + osc_utils.find_project.return_value.id = response['tenant_id'] + # Update response(finally returns 'data') + self.data = _generate_data(ordered_dict=response) + self.ordered_data = tuple( + response[column] for column in self.ordered_columns + ) + + def _set_all_params_cidr(self, args={}): + name = args.get('name') or 'my-name' + description = args.get('description') or 'my-desc' + endpoint_type = args.get('type') or 'cidr' + endpoints = args.get('endpoints') or ['10.0.0.0/24', '20.0.0.0/24'] + tenant_id = args.get('tenant_id') or 'my-tenant' + arglist = [ + '--description', description, + '--type', endpoint_type, + '--value', '10.0.0.0/24', + '--value', '20.0.0.0/24', + '--project', tenant_id, + name, + ] + verifylist = [ + ('description', description), + ('type', endpoint_type), + ('endpoints', endpoints), + ('project', tenant_id), + ('name', name), + ] + return arglist, verifylist + + def _test_create_with_all_params_cidr(self, args={}): + arglist, verifylist = self._set_all_params_cidr(args) + request, response = _generate_req_and_res(verifylist) + self._update_expect_response(request, response) + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.check_results(headers, data, request) + + def test_create_with_no_options(self): + arglist = [] + verifylist = [] + + self.assertRaises(tests_utils.ParserException, self.check_parser, + self.cmd, arglist, verifylist) + + def test_create_with_all_params_cidr(self): + self._test_create_with_all_params_cidr() + + +class TestDeleteEndpointGroup(TestEndpointGroup, common.TestDeleteVPNaaS): + + def setUp(self): + super(TestDeleteEndpointGroup, self).setUp() + self.neutronclient.delete_endpoint_group = mock.Mock( + return_value={self.res: _endpoint_group}) + self.mocked = self.neutronclient.delete_endpoint_group + self.cmd = endpoint_group.DeleteEndpointGroup(self.app, self.namespace) + + +class TestListEndpointGroup(TestEndpointGroup): + + def setUp(self): + super(TestListEndpointGroup, self).setUp() + self.cmd = endpoint_group.ListEndpointGroup(self.app, self.namespace) + + self.short_header = ( + 'ID', + 'Name', + 'Type', + 'Endpoints', + ) + + self.short_data = ( + _endpoint_group['id'], + _endpoint_group['name'], + _endpoint_group['type'], + _endpoint_group['endpoints'], + ) + + self.neutronclient.list_endpoint_groups = mock.Mock( + return_value={self.res_plural: [_endpoint_group]}) + self.mocked = self.neutronclient.list_endpoint_groups + + def test_list_with_long_option(self): + arglist = ['--long'] + verifylist = [('long', True)] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.headers), headers) + self.assertEqual([self.data], list(data)) + + def test_list_with_no_option(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.short_header), headers) + self.assertEqual([self.short_data], list(data)) + + +class TestSetEndpointGroup(TestEndpointGroup, common.TestSetVPNaaS): + + def setUp(self): + super(TestSetEndpointGroup, self).setUp() + self.neutronclient.update_endpoint_group = mock.Mock( + return_value={self.res: _endpoint_group}) + self.mocked = self.neutronclient.update_endpoint_group + self.cmd = endpoint_group.SetEndpointGroup(self.app, self.namespace) + + +class TestShowEndpointGroup(TestEndpointGroup, common.TestShowVPNaaS): + + def setUp(self): + super(TestShowEndpointGroup, self).setUp() + self.neutronclient.show_endpoint_group = mock.Mock( + return_value={self.res: _endpoint_group}) + self.mocked = self.neutronclient.show_endpoint_group + self.cmd = endpoint_group.ShowEndpointGroup(self.app, self.namespace) diff --git a/neutronclient/tests/unit/osc/v2/vpnaas/test_ikepolicy.py b/neutronclient/tests/unit/osc/v2/vpnaas/test_ikepolicy.py new file mode 100644 index 0000000..24663d6 --- /dev/null +++ b/neutronclient/tests/unit/osc/v2/vpnaas/test_ikepolicy.py @@ -0,0 +1,303 @@ +# Copyright 2017 FUJITSU LIMITED +# All Rights Reserved +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import copy + +import mock +from osc_lib.tests import utils as tests_utils + +from neutronclient.osc import utils as osc_utils +from neutronclient.osc.v2.vpnaas import ikepolicy +from neutronclient.tests.unit.osc.v2 import fakes as test_fakes +from neutronclient.tests.unit.osc.v2.vpnaas import common +from neutronclient.tests.unit.osc.v2.vpnaas import fakes + + +_ikepolicy = fakes.IKEPolicy().create() +CONVERT_MAP = { + 'project': 'tenant_id', +} + + +def _generate_data(ordered_dict=None, data=None): + source = ordered_dict if ordered_dict else _ikepolicy + if data: + source.update(data) + return tuple(source[key] for key in source) + + +def _generate_req_and_res(verifylist): + request = dict(verifylist) + response = copy.deepcopy(_ikepolicy) + for key, val in verifylist: + converted = CONVERT_MAP.get(key, key) + del request[key] + new_value = val + request[converted] = new_value + response[converted] = new_value + return request, response + + +class TestIKEPolicy(test_fakes.TestNeutronClientOSCV2): + + def check_results(self, headers, data, exp_req, is_list=False): + if is_list: + req_body = {self.res_plural: [exp_req]} + else: + req_body = {self.res: exp_req} + self.mocked.assert_called_once_with(req_body) + self.assertEqual(self.ordered_headers, headers) + self.assertEqual(self.ordered_data, data) + + def setUp(self): + super(TestIKEPolicy, self).setUp() + + def _mock_ikepolicy(*args, **kwargs): + self.neutronclient.find_resource.assert_called_once_with( + self.res, self.resource['id'], cmd_resource='ikepolicy') + return {'id': args[1]} + + self.neutronclient.find_resource.side_effect = mock.Mock( + side_effect=_mock_ikepolicy) + osc_utils.find_project = mock.Mock() + osc_utils.find_project.id = _ikepolicy['tenant_id'] + self.res = 'ikepolicy' + self.res_plural = 'ikepolicies' + self.resource = _ikepolicy + self.headers = ( + 'ID', + 'Name', + 'Authentication Algorithm', + 'Encryption Algorithm', + 'IKE Version', + 'Perfect Forward Secrecy (PFS)', + 'Description', + 'Phase1 Negotiation Mode', + 'Project', + 'Lifetime', + ) + self.data = _generate_data() + self.ordered_headers = ( + 'Authentication Algorithm', + 'Description', + 'Encryption Algorithm', + 'ID', + 'IKE Version', + 'Lifetime', + 'Name', + 'Perfect Forward Secrecy (PFS)', + 'Phase1 Negotiation Mode', + 'Project', + ) + self.ordered_data = ( + _ikepolicy['auth_algorithm'], + _ikepolicy['description'], + _ikepolicy['encryption_algorithm'], + _ikepolicy['id'], + _ikepolicy['ike_version'], + _ikepolicy['lifetime'], + _ikepolicy['name'], + _ikepolicy['pfs'], + _ikepolicy['phase1_negotiation_mode'], + _ikepolicy['tenant_id'], + ) + self.ordered_columns = ( + 'auth_algorithm', + 'description', + 'encryption_algorithm', + 'id', + 'ike_version', + 'lifetime', + 'name', + 'pfs', + 'phase1_negotiation_mode', + 'tenant_id', + ) + + +class TestCreateIKEPolicy(TestIKEPolicy, common.TestCreateVPNaaS): + + def setUp(self): + super(TestCreateIKEPolicy, self).setUp() + self.neutronclient.create_ikepolicy = mock.Mock( + return_value={self.res: _ikepolicy}) + self.mocked = self.neutronclient.create_ikepolicy + self.cmd = ikepolicy.CreateIKEPolicy(self.app, self.namespace) + + def _update_expect_response(self, request, response): + """Set expected request and response + + :param request + A dictionary of request body(dict of verifylist) + :param response + A OrderedDict of request body + """ + # Update response body + self.neutronclient.create_ikepolicy.return_value = \ + {self.res: dict(response)} + osc_utils.find_project.return_value.id = response['tenant_id'] + # Update response(finally returns 'data') + self.data = _generate_data(ordered_dict=response) + self.ordered_data = tuple( + response[column] for column in self.ordered_columns + ) + + def _set_all_params(self, args={}): + name = args.get('name') or 'my-name' + description = args.get('description') or 'my-desc' + auth_algorithm = args.get('auth_algorithm') or 'sha1' + encryption_algorithm = args.get('encryption_algorithm') or 'aes-128' + phase1_negotiation_mode = args.get('phase1_negotiation_mode') or 'main' + ike_version = args.get('ike_version') or 'v1' + pfs = args.get('pfs') or 'group5' + tenant_id = args.get('tenant_id') or 'my-tenant' + arglist = [ + '--description', description, + '--auth-algorithm', auth_algorithm, + '--encryption-algorithm', encryption_algorithm, + '--phase1-negotiation-mode', phase1_negotiation_mode, + '--ike-version', ike_version, + '--pfs', pfs, + '--project', tenant_id, + name, + ] + verifylist = [ + ('description', description), + ('auth_algorithm', auth_algorithm), + ('encryption_algorithm', encryption_algorithm), + ('phase1_negotiation_mode', phase1_negotiation_mode), + ('ike_version', ike_version), + ('pfs', pfs), + ('project', tenant_id), + ('name', name), + ] + return arglist, verifylist + + def _test_create_with_all_params(self, args={}): + arglist, verifylist = self._set_all_params(args) + request, response = _generate_req_and_res(verifylist) + self._update_expect_response(request, response) + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.check_results(headers, data, request) + + def test_create_with_no_options(self): + arglist = [] + verifylist = [] + + self.assertRaises(tests_utils.ParserException, self.check_parser, + self.cmd, arglist, verifylist) + + def test_create_with_all_params(self): + self._test_create_with_all_params() + + def test_create_with_all_params_name(self): + self._test_create_with_all_params({'name': 'new_ikepolicy'}) + + +class TestDeleteIKEPolicy(TestIKEPolicy, common.TestDeleteVPNaaS): + + def setUp(self): + super(TestDeleteIKEPolicy, self).setUp() + self.neutronclient.delete_ikepolicy = mock.Mock( + return_value={self.res: _ikepolicy}) + self.mocked = self.neutronclient.delete_ikepolicy + self.cmd = ikepolicy.DeleteIKEPolicy(self.app, self.namespace) + + +class TestListIKEPolicy(TestIKEPolicy): + + def setUp(self): + super(TestListIKEPolicy, self).setUp() + self.cmd = ikepolicy.ListIKEPolicy(self.app, self.namespace) + + self.short_header = ( + 'ID', + 'Name', + 'Authentication Algorithm', + 'Encryption Algorithm', + 'IKE Version', + 'Perfect Forward Secrecy (PFS)', + ) + + self.short_data = ( + _ikepolicy['id'], + _ikepolicy['name'], + _ikepolicy['auth_algorithm'], + _ikepolicy['encryption_algorithm'], + _ikepolicy['ike_version'], + _ikepolicy['pfs'], + ) + + self.neutronclient.list_ikepolicies = mock.Mock( + return_value={self.res_plural: [_ikepolicy]}) + self.mocked = self.neutronclient.list_ikepolicies + + def test_list_with_long_option(self): + arglist = ['--long'] + verifylist = [('long', True)] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.headers), headers) + self.assertEqual([self.data], list(data)) + + def test_list_with_no_option(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.short_header), headers) + self.assertEqual([self.short_data], list(data)) + + +class TestSetIKEPolicy(TestIKEPolicy, common.TestSetVPNaaS): + + def setUp(self): + super(TestSetIKEPolicy, self).setUp() + self.neutronclient.update_ikepolicy = mock.Mock( + return_value={self.res: _ikepolicy}) + self.mocked = self.neutronclient.update_ikepolicy + self.cmd = ikepolicy.SetIKEPolicy(self.app, self.namespace) + + def test_set_auth_algorithm_with_sha256(self): + target = self.resource['id'] + auth_algorithm = 'sha256' + arglist = [target, '--auth-algorithm', auth_algorithm] + verifylist = [ + (self.res, target), + ('auth_algorithm', auth_algorithm), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with( + target, {self.res: {'auth_algorithm': 'sha256'}}) + self.assertIsNone(result) + + +class TestShowIKEPolicy(TestIKEPolicy, common.TestShowVPNaaS): + + def setUp(self): + super(TestShowIKEPolicy, self).setUp() + self.neutronclient.show_ikepolicy = mock.Mock( + return_value={self.res: _ikepolicy}) + self.mocked = self.neutronclient.show_ikepolicy + self.cmd = ikepolicy.ShowIKEPolicy(self.app, self.namespace) diff --git a/neutronclient/tests/unit/osc/v2/vpnaas/test_ipsec_site_connection.py b/neutronclient/tests/unit/osc/v2/vpnaas/test_ipsec_site_connection.py new file mode 100644 index 0000000..4d04b64 --- /dev/null +++ b/neutronclient/tests/unit/osc/v2/vpnaas/test_ipsec_site_connection.py @@ -0,0 +1,381 @@ +# Copyright 2017 FUJITSU LIMITED +# All Rights Reserved +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import copy + +import mock +from osc_lib.cli import format_columns +from osc_lib.tests import utils as tests_utils + +from neutronclient.osc import utils as osc_utils +from neutronclient.osc.v2.vpnaas import ipsec_site_connection +from neutronclient.tests.unit.osc.v2 import fakes as test_fakes +from neutronclient.tests.unit.osc.v2.vpnaas import common +from neutronclient.tests.unit.osc.v2.vpnaas import fakes + + +_ipsec_site_conn = fakes.IPsecSiteConnection().create_conn() +CONVERT_MAP = { + 'project': 'tenant_id', + 'ikepolicy': 'ikepolicy_id', + 'ipsecpolicy': 'ipsecpolicy_id', + 'vpnservice': 'vpnservice_id', + 'peer_endpoint_group': 'peer_ep_group_id', + 'local_endpoint_group': 'local_ep_group_id', +} + + +def _generate_data(ordered_dict=None, data=None): + source = ordered_dict if ordered_dict else _ipsec_site_conn + if data: + source.update(data) + return ( + _ipsec_site_conn['id'], + _ipsec_site_conn['name'], + _ipsec_site_conn['peer_address'], + _ipsec_site_conn['auth_mode'], + _ipsec_site_conn['status'], + _ipsec_site_conn['tenant_id'], + format_columns.ListColumn(_ipsec_site_conn['peer_cidrs']), + _ipsec_site_conn['vpnservice_id'], + _ipsec_site_conn['ipsecpolicy_id'], + _ipsec_site_conn['ikepolicy_id'], + _ipsec_site_conn['mtu'], + _ipsec_site_conn['initiator'], + _ipsec_site_conn['admin_state_up'], + _ipsec_site_conn['description'], + _ipsec_site_conn['psk'], + _ipsec_site_conn['route_mode'], + _ipsec_site_conn['local_id'], + _ipsec_site_conn['peer_id'], + _ipsec_site_conn['local_ep_group_id'], + _ipsec_site_conn['peer_ep_group_id'], + ) + + +def _generate_req_and_res(verifylist): + request = dict(verifylist) + response = copy.deepcopy(_ipsec_site_conn) + for key, val in verifylist: + converted = CONVERT_MAP.get(key, key) + del request[key] + new_value = val + request[converted] = new_value + response[converted] = new_value + return request, response + + +class TestIPsecSiteConn(test_fakes.TestNeutronClientOSCV2): + + def check_results(self, headers, data, exp_req, is_list=False): + if is_list: + req_body = {self.res_plural: [exp_req]} + else: + req_body = {self.res: exp_req} + self.mocked.assert_called_once_with(req_body) + self.assertEqual(self.ordered_headers, headers) + self.assertItemEqual(self.ordered_data, data) + + def setUp(self): + super(TestIPsecSiteConn, self).setUp() + + def _mock_ipsec_site_conn(*args, **kwargs): + return {'id': args[1]} + + self.neutronclient.find_resource.side_effect = mock.Mock( + side_effect=_mock_ipsec_site_conn) + osc_utils.find_project = mock.Mock() + osc_utils.find_project.id = _ipsec_site_conn['tenant_id'] + self.res = 'ipsec_site_connection' + self.res_plural = 'ipsec_site_connections' + self.resource = _ipsec_site_conn + self.headers = ( + 'ID', + 'Name', + 'Peer Address', + 'Authentication Algorithm', + 'Status', + 'Project', + 'Peer CIDRs', + 'VPN Service', + 'IPSec Policy', + 'IKE Policy', + 'MTU', + 'Initiator', + 'State', + 'Description', + 'Pre-shared Key', + 'Route Mode', + 'Local ID', + 'Peer ID', + 'Local Endpoint Group ID', + 'Peer Endpoint Group ID' + ) + self.data = _generate_data() + self.ordered_headers = ( + 'Authentication Algorithm', + 'Description', + 'ID', + 'IKE Policy', + 'IPSec Policy', + 'Initiator', + 'Local Endpoint Group ID', + 'Local ID', + 'MTU', + 'Name', + 'Peer Address', + 'Peer CIDRs', + 'Peer Endpoint Group ID', + 'Peer ID', + 'Pre-shared Key', + 'Project', + 'Route Mode', + 'State', + 'Status', + 'VPN Service', + ) + self.ordered_data = ( + _ipsec_site_conn['auth_mode'], + _ipsec_site_conn['description'], + _ipsec_site_conn['id'], + _ipsec_site_conn['ikepolicy_id'], + _ipsec_site_conn['ipsecpolicy_id'], + _ipsec_site_conn['initiator'], + _ipsec_site_conn['local_ep_group_id'], + _ipsec_site_conn['local_id'], + _ipsec_site_conn['mtu'], + _ipsec_site_conn['name'], + _ipsec_site_conn['peer_address'], + format_columns.ListColumn(_ipsec_site_conn['peer_cidrs']), + _ipsec_site_conn['peer_ep_group_id'], + _ipsec_site_conn['peer_id'], + _ipsec_site_conn['psk'], + _ipsec_site_conn['tenant_id'], + _ipsec_site_conn['route_mode'], + _ipsec_site_conn['admin_state_up'], + _ipsec_site_conn['status'], + _ipsec_site_conn['vpnservice_id'], + ) + + +class TestCreateIPsecSiteConn(TestIPsecSiteConn, common.TestCreateVPNaaS): + + def setUp(self): + super(TestCreateIPsecSiteConn, self).setUp() + self.neutronclient.create_ipsec_site_connection = mock.Mock( + return_value={self.res: _ipsec_site_conn}) + self.mocked = self.neutronclient.create_ipsec_site_connection + self.cmd = ipsec_site_connection.CreateIPsecSiteConnection( + self.app, self.namespace) + + def _update_expect_response(self, request, response): + """Set expected request and response + + :param request + A dictionary of request body(dict of verifylist) + :param response + A OrderedDict of request body + """ + # Update response body + self.neutronclient.create_ipsec_site_connection.return_value = \ + {self.res: dict(response)} + osc_utils.find_project.return_value.id = response['tenant_id'] + # Update response(finally returns 'data') + self.data = _generate_data(ordered_dict=response) + self.ordered_data = ( + response['auth_mode'], + response['description'], + response['id'], + response['ikepolicy_id'], + response['ipsecpolicy_id'], + response['initiator'], + response['local_ep_group_id'], + response['local_id'], + response['mtu'], + response['name'], + response['peer_address'], + format_columns.ListColumn(response['peer_cidrs']), + response['peer_ep_group_id'], + response['peer_id'], + response['psk'], + response['tenant_id'], + response['route_mode'], + response['admin_state_up'], + response['status'], + response['vpnservice_id'], + ) + + def _set_all_params(self, args={}): + tenant_id = args.get('tenant_id') or 'my-tenant' + name = args.get('name') or 'connection1' + peer_address = args.get('peer_address') or '192.168.2.10' + peer_id = args.get('peer_id') or '192.168.2.10' + psk = args.get('psk') or 'abcd' + mtu = args.get('mtu') or '1500' + initiator = args.get('initiator') or 'bi-directional' + vpnservice_id = args.get('vpnservice') or 'vpnservice_id' + ikepolicy_id = args.get('ikepolicy') or 'ikepolicy_id' + ipsecpolicy_id = args.get('ipsecpolicy') or 'ipsecpolicy_id' + local_ep_group = args.get('local_ep_group_id') or 'local-epg' + peer_ep_group = args.get('peer_ep_group_id') or 'peer-epg' + description = args.get('description') or 'my-vpn-connection' + + arglist = [ + '--project', tenant_id, + '--peer-address', peer_address, + '--peer-id', peer_id, + '--psk', psk, + '--initiator', initiator, + '--vpnservice', vpnservice_id, + '--ikepolicy', ikepolicy_id, + '--ipsecpolicy', ipsecpolicy_id, + '--mtu', mtu, + '--description', description, + '--local-endpoint-group', local_ep_group, + '--peer-endpoint-group', peer_ep_group, + name, + ] + verifylist = [ + ('project', tenant_id), + ('peer_address', peer_address), + ('peer_id', peer_id), + ('psk', psk), + ('initiator', initiator), + ('vpnservice', vpnservice_id), + ('ikepolicy', ikepolicy_id), + ('ipsecpolicy', ipsecpolicy_id), + ('mtu', mtu), + ('description', description), + ('local_endpoint_group', local_ep_group), + ('peer_endpoint_group', peer_ep_group), + ('name', name), + ] + return arglist, verifylist + + def _test_create_with_all_params(self, args={}): + arglist, verifylist = self._set_all_params(args) + request, response = _generate_req_and_res(verifylist) + self._update_expect_response(request, response) + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.check_results(headers, data, request) + + def test_create_with_no_options(self): + arglist = [] + verifylist = [] + + self.assertRaises(tests_utils.ParserException, self.check_parser, + self.cmd, arglist, verifylist) + + def test_create_with_all_params(self): + self._test_create_with_all_params() + + +class TestDeleteIPsecSiteConn(TestIPsecSiteConn, common.TestDeleteVPNaaS): + + def setUp(self): + super(TestDeleteIPsecSiteConn, self).setUp() + self.neutronclient.delete_ipsec_site_connection = mock.Mock( + return_value={self.res: _ipsec_site_conn}) + self.mocked = self.neutronclient.delete_ipsec_site_connection + self.cmd = ipsec_site_connection.DeleteIPsecSiteConnection( + self.app, self.namespace) + + +class TestListIPsecSiteConn(TestIPsecSiteConn): + + def setUp(self): + super(TestListIPsecSiteConn, self).setUp() + self.cmd = ipsec_site_connection.ListIPsecSiteConnection( + self.app, self.namespace) + + self.short_header = ( + 'ID', + 'Name', + 'Peer Address', + 'Authentication Algorithm', + 'Status', + ) + + self.short_data = ( + _ipsec_site_conn['id'], + _ipsec_site_conn['name'], + _ipsec_site_conn['peer_address'], + _ipsec_site_conn['auth_mode'], + _ipsec_site_conn['status'], + ) + + self.neutronclient.list_ipsec_site_connections = mock.Mock( + return_value={self.res_plural: [_ipsec_site_conn]}) + self.mocked = self.neutronclient.list_ipsec_site_connections + + def test_list_with_long_option(self): + arglist = ['--long'] + verifylist = [('long', True)] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.headers), headers) + self.assertListItemEqual([self.data], list(data)) + + def test_list_with_no_option(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.short_header), headers) + self.assertEqual([self.short_data], list(data)) + + +class TestSetIPsecSiteConn(TestIPsecSiteConn, common.TestSetVPNaaS): + + def setUp(self): + super(TestSetIPsecSiteConn, self).setUp() + self.neutronclient.update_ipsec_site_connection = mock.Mock( + return_value={self.res: _ipsec_site_conn}) + self.mocked = self.neutronclient.update_ipsec_site_connection + self.cmd = ipsec_site_connection.SetIPsecSiteConnection( + self.app, self.namespace) + + def test_set_ipsec_site_conn_with_peer_id(self): + target = self.resource['id'] + peer_id = '192.168.3.10' + arglist = [target, '--peer-id', peer_id] + verifylist = [ + (self.res, target), + ('peer_id', peer_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with( + target, {self.res: {'peer_id': peer_id}}) + self.assertIsNone(result) + + +class TestShowIPsecSiteConn(TestIPsecSiteConn, common.TestShowVPNaaS): + + def setUp(self): + super(TestShowIPsecSiteConn, self).setUp() + self.neutronclient.show_ipsec_site_connection = mock.Mock( + return_value={self.res: _ipsec_site_conn}) + self.mocked = self.neutronclient.show_ipsec_site_connection + self.cmd = ipsec_site_connection.ShowIPsecSiteConnection( + self.app, self.namespace) diff --git a/neutronclient/tests/unit/osc/v2/vpnaas/test_ipsecpolicy.py b/neutronclient/tests/unit/osc/v2/vpnaas/test_ipsecpolicy.py new file mode 100644 index 0000000..8e56cf3 --- /dev/null +++ b/neutronclient/tests/unit/osc/v2/vpnaas/test_ipsecpolicy.py @@ -0,0 +1,303 @@ +# Copyright 2017 FUJITSU LIMITED +# All Rights Reserved +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import copy + +import mock +from osc_lib.tests import utils as tests_utils + +from neutronclient.osc import utils as osc_utils +from neutronclient.osc.v2.vpnaas import ipsecpolicy +from neutronclient.tests.unit.osc.v2 import fakes as test_fakes +from neutronclient.tests.unit.osc.v2.vpnaas import common +from neutronclient.tests.unit.osc.v2.vpnaas import fakes + + +_ipsecpolicy = fakes.IPSecPolicy().create() +CONVERT_MAP = { + 'project': 'tenant_id', +} + + +def _generate_data(ordered_dict=None, data=None): + source = ordered_dict if ordered_dict else _ipsecpolicy + if data: + source.update(data) + return tuple(source[key] for key in source) + + +def _generate_req_and_res(verifylist): + request = dict(verifylist) + response = copy.deepcopy(_ipsecpolicy) + for key, val in verifylist: + converted = CONVERT_MAP.get(key, key) + del request[key] + new_value = val + request[converted] = new_value + response[converted] = new_value + return request, response + + +class TestIPSecPolicy(test_fakes.TestNeutronClientOSCV2): + + def check_results(self, headers, data, exp_req, is_list=False): + if is_list: + req_body = {self.res_plural: [exp_req]} + else: + req_body = {self.res: exp_req} + self.mocked.assert_called_once_with(req_body) + self.assertEqual(self.ordered_headers, headers) + self.assertEqual(self.ordered_data, data) + + def setUp(self): + super(TestIPSecPolicy, self).setUp() + + def _mock_ipsecpolicy(*args, **kwargs): + self.neutronclient.find_resource.assert_called_once_with( + self.res, self.resource['id'], cmd_resource='ipsecpolicy') + return {'id': args[1]} + + self.neutronclient.find_resource.side_effect = mock.Mock( + side_effect=_mock_ipsecpolicy) + osc_utils.find_project = mock.Mock() + osc_utils.find_project.id = _ipsecpolicy['tenant_id'] + self.res = 'ipsecpolicy' + self.res_plural = 'ipsecpolicies' + self.resource = _ipsecpolicy + self.headers = ( + 'ID', + 'Name', + 'Authentication Algorithm', + 'Encapsulation Mode', + 'Transform Protocol', + 'Encryption Algorithm', + 'Perfect Forward Secrecy (PFS)', + 'Description', + 'Project', + 'Lifetime', + ) + self.data = _generate_data() + self.ordered_headers = ( + 'Authentication Algorithm', + 'Description', + 'Encapsulation Mode', + 'Encryption Algorithm', + 'ID', + 'Lifetime', + 'Name', + 'Perfect Forward Secrecy (PFS)', + 'Project', + 'Transform Protocol', + ) + self.ordered_data = ( + _ipsecpolicy['auth_algorithm'], + _ipsecpolicy['description'], + _ipsecpolicy['encapsulation_mode'], + _ipsecpolicy['encryption_algorithm'], + _ipsecpolicy['id'], + _ipsecpolicy['lifetime'], + _ipsecpolicy['name'], + _ipsecpolicy['pfs'], + _ipsecpolicy['tenant_id'], + _ipsecpolicy['transform_protocol'], + ) + self.ordered_columns = ( + 'auth_algorithm', + 'description', + 'encapsulation_mode', + 'encryption_algorithm', + 'id', + 'lifetime', + 'name', + 'pfs', + 'tenant_id', + 'transform_protocol', + ) + + +class TestCreateIPSecPolicy(TestIPSecPolicy, common.TestCreateVPNaaS): + + def setUp(self): + super(TestCreateIPSecPolicy, self).setUp() + self.neutronclient.create_ipsecpolicy = mock.Mock( + return_value={self.res: _ipsecpolicy}) + self.mocked = self.neutronclient.create_ipsecpolicy + self.cmd = ipsecpolicy.CreateIPsecPolicy(self.app, self.namespace) + + def _update_expect_response(self, request, response): + """Set expected request and response + + :param request + A dictionary of request body(dict of verifylist) + :param response + A OrderedDict of request body + """ + # Update response body + self.neutronclient.create_ipsecpolicy.return_value = \ + {self.res: dict(response)} + osc_utils.find_project.return_value.id = response['tenant_id'] + # Update response(finally returns 'data') + self.data = _generate_data(ordered_dict=response) + self.ordered_data = tuple( + response[column] for column in self.ordered_columns + ) + + def _set_all_params(self, args={}): + name = args.get('name') or 'my-name' + auth_algorithm = args.get('auth_algorithm') or 'sha1' + encapsulation_mode = args.get('encapsulation_mode') or 'tunnel' + transform_protocol = args.get('transform_protocol') or 'esp' + encryption_algorithm = args.get('encryption_algorithm') or 'aes-128' + pfs = args.get('pfs') or 'group5' + description = args.get('description') or 'my-desc' + tenant_id = args.get('tenant_id') or 'my-tenant' + arglist = [ + name, + '--auth-algorithm', auth_algorithm, + '--encapsulation-mode', encapsulation_mode, + '--transform-protocol', transform_protocol, + '--encryption-algorithm', encryption_algorithm, + '--pfs', pfs, + '--description', description, + '--project', tenant_id, + ] + verifylist = [ + ('name', name), + ('auth_algorithm', auth_algorithm), + ('encapsulation_mode', encapsulation_mode), + ('transform_protocol', transform_protocol), + ('encryption_algorithm', encryption_algorithm), + ('pfs', pfs), + ('description', description), + ('project', tenant_id), + ] + return arglist, verifylist + + def _test_create_with_all_params(self, args={}): + arglist, verifylist = self._set_all_params(args) + request, response = _generate_req_and_res(verifylist) + self._update_expect_response(request, response) + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.check_results(headers, data, request) + + def test_create_with_no_options(self): + arglist = [] + verifylist = [] + + self.assertRaises(tests_utils.ParserException, self.check_parser, + self.cmd, arglist, verifylist) + + def test_create_with_all_params(self): + self._test_create_with_all_params() + + def test_create_with_all_params_name(self): + self._test_create_with_all_params({'name': 'new_ipsecpolicy'}) + + +class TestDeleteIPSecPolicy(TestIPSecPolicy, common.TestDeleteVPNaaS): + + def setUp(self): + super(TestDeleteIPSecPolicy, self).setUp() + self.neutronclient.delete_ipsecpolicy = mock.Mock( + return_value={self.res: _ipsecpolicy}) + self.mocked = self.neutronclient.delete_ipsecpolicy + self.cmd = ipsecpolicy.DeleteIPsecPolicy(self.app, self.namespace) + + +class TestListIPSecPolicy(TestIPSecPolicy): + + def setUp(self): + super(TestListIPSecPolicy, self).setUp() + self.cmd = ipsecpolicy.ListIPsecPolicy(self.app, self.namespace) + + self.short_header = ( + 'ID', + 'Name', + 'Authentication Algorithm', + 'Encapsulation Mode', + 'Transform Protocol', + 'Encryption Algorithm', + ) + + self.short_data = ( + _ipsecpolicy['id'], + _ipsecpolicy['name'], + _ipsecpolicy['auth_algorithm'], + _ipsecpolicy['encapsulation_mode'], + _ipsecpolicy['transform_protocol'], + _ipsecpolicy['encryption_algorithm'], + ) + + self.neutronclient.list_ipsecpolicies = mock.Mock( + return_value={self.res_plural: [_ipsecpolicy]}) + self.mocked = self.neutronclient.list_ipsecpolicies + + def test_list_with_long_option(self): + arglist = ['--long'] + verifylist = [('long', True)] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.headers), headers) + self.assertEqual([self.data], list(data)) + + def test_list_with_no_option(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.short_header), headers) + self.assertEqual([self.short_data], list(data)) + + +class TestSetIPSecPolicy(TestIPSecPolicy, common.TestSetVPNaaS): + + def setUp(self): + super(TestSetIPSecPolicy, self).setUp() + self.neutronclient.update_ipsecpolicy = mock.Mock( + return_value={self.res: _ipsecpolicy}) + self.mocked = self.neutronclient.update_ipsecpolicy + self.cmd = ipsecpolicy.SetIPsecPolicy(self.app, self.namespace) + + def test_set_auth_algorithm_with_sha256(self): + target = self.resource['id'] + auth_algorithm = 'sha256' + arglist = [target, '--auth-algorithm', auth_algorithm] + verifylist = [ + (self.res, target), + ('auth_algorithm', auth_algorithm), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with( + target, {self.res: {'auth_algorithm': 'sha256'}}) + self.assertIsNone(result) + + +class TestShowIPSecPolicy(TestIPSecPolicy, common.TestShowVPNaaS): + + def setUp(self): + super(TestShowIPSecPolicy, self).setUp() + self.neutronclient.show_ipsecpolicy = mock.Mock( + return_value={self.res: _ipsecpolicy}) + self.mocked = self.neutronclient.show_ipsecpolicy + self.cmd = ipsecpolicy.ShowIPsecPolicy(self.app, self.namespace) diff --git a/neutronclient/tests/unit/osc/v2/vpnaas/test_vpnservice.py b/neutronclient/tests/unit/osc/v2/vpnaas/test_vpnservice.py new file mode 100644 index 0000000..a9c208e --- /dev/null +++ b/neutronclient/tests/unit/osc/v2/vpnaas/test_vpnservice.py @@ -0,0 +1,305 @@ +# Copyright 2017 FUJITSU LIMITED +# All Rights Reserved +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import copy +import uuid + +import mock + +from neutronclient.osc import utils as osc_utils +from neutronclient.osc.v2.vpnaas import vpnservice +from neutronclient.tests.unit.osc.v2 import fakes as test_fakes +from neutronclient.tests.unit.osc.v2.vpnaas import common +from neutronclient.tests.unit.osc.v2.vpnaas import fakes + + +_vpnservice = fakes.VPNService().create() +CONVERT_MAP = { + 'project': 'tenant_id', + 'router': 'router_id', + 'subnet': 'subnet_id' +} + + +def _generate_data(ordered_dict=None, data=None): + source = ordered_dict if ordered_dict else _vpnservice + if data: + source.update(data) + return tuple(source[key] for key in source) + + +def _generate_req_and_res(verifylist): + request = dict(verifylist) + response = copy.deepcopy(_vpnservice) + for key, val in verifylist: + converted = CONVERT_MAP.get(key, key) + del request[key] + new_value = val + request[converted] = new_value + response[converted] = new_value + return request, response + + +class TestVPNService(test_fakes.TestNeutronClientOSCV2): + + def _check_results(self, headers, data, exp_req, is_list=False): + if is_list: + req_body = {self.res_plural: [exp_req]} + else: + req_body = {self.res: exp_req} + self.mocked.assert_called_once_with(req_body) + self.assertEqual(self.ordered_headers, headers) + self.assertEqual(self.ordered_data, data) + + def setUp(self): + super(TestVPNService, self).setUp() + + def _mock_vpnservice(*args, **kwargs): + self.neutronclient.find_resource.assert_called_once_with( + self.res, self.resource['id'], cmd_resource='vpnservice') + return {'id': args[1]} + + self.app.client_manager.network = mock.Mock() + self.app.client_manager.network.find_router = mock.Mock() + self.app.client_manager.network.find_subnet = mock.Mock() + self.fake_router = mock.Mock() + self.fake_subnet = mock.Mock() + self.app.client_manager.network.find_router.return_value = \ + self.fake_router + self.app.client_manager.network.find_subnet.return_value = \ + self.fake_subnet + self.args = { + 'name': 'my-name', + 'description': 'my-desc', + 'tenant_id': 'tenant-id-' + uuid.uuid4().hex, + 'router_id': 'router-id-' + uuid.uuid4().hex, + 'subnet_id': 'subnet-id-' + uuid.uuid4().hex, + + } + self.fake_subnet.id = self.args['subnet_id'] + self.fake_router.id = self.args['router_id'] + + self.neutronclient.find_resource.side_effect = mock.Mock( + side_effect=_mock_vpnservice) + osc_utils.find_project = mock.Mock() + osc_utils.find_project.id = _vpnservice['tenant_id'] + + self.res = 'vpnservice' + self.res_plural = 'vpnservices' + self.resource = _vpnservice + self.headers = ( + 'ID', + 'Name', + 'Router', + 'Subnet', + 'Flavor', + 'State', + 'Status', + 'Description', + 'Project', + ) + self.data = _generate_data() + self.ordered_headers = ( + 'Description', + 'Flavor', + 'ID', + 'Name', + 'Project', + 'Router', + 'State', + 'Status', + 'Subnet', + ) + self.ordered_data = ( + _vpnservice['description'], + _vpnservice['flavor_id'], + _vpnservice['id'], + _vpnservice['name'], + _vpnservice['tenant_id'], + _vpnservice['router_id'], + _vpnservice['admin_state_up'], + _vpnservice['status'], + _vpnservice['subnet_id'], + ) + self.ordered_columns = ( + 'description', + 'flavor_id', + 'id', + 'name', + 'tenant_id', + 'router_id', + 'admin_state_up', + 'status', + 'subnet_id', + ) + + +class TestCreateVPNService(TestVPNService, common.TestCreateVPNaaS): + + def setUp(self): + super(TestCreateVPNService, self).setUp() + self.neutronclient.create_vpnservice = mock.Mock( + return_value={self.res: _vpnservice}) + self.mocked = self.neutronclient.create_vpnservice + self.cmd = vpnservice.CreateVPNService(self.app, self.namespace) + + def _update_expect_response(self, request, response): + """Set expected request and response + + :param request + A dictionary of request body(dict of verifylist) + :param response + A OrderedDict of request body + """ + # Update response body + self.neutronclient.create_vpnservice.return_value = \ + {self.res: dict(response)} + osc_utils.find_project.return_value.id = response['tenant_id'] + # Update response(finally returns 'data') + self.data = _generate_data(ordered_dict=response) + self.ordered_data = tuple( + response[column] for column in self.ordered_columns + ) + + def _set_all_params(self): + name = self.args.get('name') + description = self.args.get('description') + router_id = self.args.get('router_id') + subnet_id = self.args.get('subnet_id') + tenant_id = self.args.get('tenant_id') + arglist = [ + '--description', description, + '--project', tenant_id, + '--subnet', subnet_id, + '--router', router_id, + name, + ] + verifylist = [ + ('description', description), + ('project', tenant_id), + ('subnet', subnet_id), + ('router', router_id), + ('name', name), + ] + return arglist, verifylist + + def _test_create_with_all_params(self): + arglist, verifylist = self._set_all_params() + request, response = _generate_req_and_res(verifylist) + self._update_expect_response(request, response) + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self._check_results(headers, data, request) + + def test_create_with_all_params(self): + self._test_create_with_all_params() + + +class TestDeleteVPNService(TestVPNService, common.TestDeleteVPNaaS): + + def setUp(self): + super(TestDeleteVPNService, self).setUp() + self.neutronclient.delete_vpnservice = mock.Mock( + return_value={self.res: _vpnservice}) + self.mocked = self.neutronclient.delete_vpnservice + self.cmd = vpnservice.DeleteVPNService(self.app, self.namespace) + + +class TestListVPNService(TestVPNService): + + def setUp(self): + super(TestListVPNService, self).setUp() + self.cmd = vpnservice.ListVPNService(self.app, self.namespace) + + self.short_header = ( + 'ID', + 'Name', + 'Router', + 'Subnet', + 'Flavor', + 'State', + 'Status', + ) + + self.short_data = ( + _vpnservice['id'], + _vpnservice['name'], + _vpnservice['router_id'], + _vpnservice['subnet_id'], + _vpnservice['flavor_id'], + _vpnservice['admin_state_up'], + _vpnservice['status'], + ) + + self.neutronclient.list_vpnservices = mock.Mock( + return_value={self.res_plural: [_vpnservice]}) + self.mocked = self.neutronclient.list_vpnservices + + def test_list_with_long_option(self): + arglist = ['--long'] + verifylist = [('long', True)] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.headers), headers) + self.assertEqual([self.data], list(data)) + + def test_list_with_no_option(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + headers, data = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with() + self.assertEqual(list(self.short_header), headers) + self.assertEqual([self.short_data], list(data)) + + +class TestSetVPNService(TestVPNService, common.TestSetVPNaaS): + + def setUp(self): + super(TestSetVPNService, self).setUp() + self.neutronclient.update_vpnservice = mock.Mock( + return_value={self.res: _vpnservice}) + self.mocked = self.neutronclient.update_vpnservice + self.cmd = vpnservice.SetVPNSercice(self.app, self.namespace) + + def test_set_name(self): + target = self.resource['id'] + update = 'change' + arglist = [target, '--name', update] + verifylist = [ + (self.res, target), + ('name', update), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.mocked.assert_called_once_with( + target, {self.res: {'name': update}}) + self.assertIsNone(result) + + +class TestShowVPNService(TestVPNService, common.TestShowVPNaaS): + + def setUp(self): + super(TestShowVPNService, self).setUp() + self.neutronclient.show_vpnservice = mock.Mock( + return_value={self.res: _vpnservice}) + self.mocked = self.neutronclient.show_vpnservice + self.cmd = vpnservice.ShowVPNService(self.app, self.namespace) |