From 34d23cd12720559ecb95b3783837d06746ea5518 Mon Sep 17 00:00:00 2001 From: Thiago Brito Date: Wed, 17 Feb 2021 18:05:24 -0300 Subject: [PATCH 01/16] Adding retype_volume to BlockStorageCloudMixin We are missing some "/action" operations for volumes so this patch adds the ability to retype volumes to the sdk. Signed-off-by: Thiago Brito Change-Id: I6f8d58705db3c71abffd0e939d692bb02b8b1f32 --- openstack/block_storage/v3/volume.py | 10 ++++++++++ .../tests/unit/block_storage/v3/test_proxy.py | 12 ++++++++++++ .../tests/unit/block_storage/v3/test_volume.py | 15 +++++++++++++++ 3 files changed, 37 insertions(+) diff --git a/openstack/block_storage/v3/volume.py b/openstack/block_storage/v3/volume.py index 477c03005..bef5a2fbd 100644 --- a/openstack/block_storage/v3/volume.py +++ b/openstack/block_storage/v3/volume.py @@ -119,5 +119,15 @@ class Volume(resource.Resource): body = {'os-update_readonly_flag': {'readonly': readonly}} self._action(session, body) + def retype(self, session, new_type, migration_policy): + """Retype volume considering the migration policy""" + body = { + 'os-retype': { + 'new_type': new_type, + 'migration_policy': migration_policy + } + } + self._action(session, body) + VolumeDetail = Volume diff --git a/openstack/tests/unit/block_storage/v3/test_proxy.py b/openstack/tests/unit/block_storage/v3/test_proxy.py index a83e5db4e..93b0b747b 100644 --- a/openstack/tests/unit/block_storage/v3/test_proxy.py +++ b/openstack/tests/unit/block_storage/v3/test_proxy.py @@ -172,6 +172,18 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): method_args=["value", False], expected_args=[False]) + def test_volume_retype_without_migration_policy(self): + self._verify("openstack.block_storage.v3.volume.Volume.retype", + self.proxy.retype_volume, + method_args=["value", "rbd"], + expected_args=["rbd", "never"]) + + def test_volume_retype_with_migration_policy(self): + self._verify("openstack.block_storage.v3.volume.Volume.retype", + self.proxy.retype_volume, + method_args=["value", "rbd", "on-demand"], + expected_args=["rbd", "on-demand"]) + def test_backend_pools(self): self.verify_list(self.proxy.backend_pools, stats.Pools) diff --git a/openstack/tests/unit/block_storage/v3/test_volume.py b/openstack/tests/unit/block_storage/v3/test_volume.py index ac1a238f9..b6a4fc836 100644 --- a/openstack/tests/unit/block_storage/v3/test_volume.py +++ b/openstack/tests/unit/block_storage/v3/test_volume.py @@ -147,3 +147,18 @@ class TestVolume(base.TestCase): body = {'os-update_readonly_flag': {'readonly': False}} headers = {'Accept': ''} self.sess.post.assert_called_with(url, json=body, headers=headers) + + def test_retype(self): + sot = volume.Volume(**VOLUME) + + self.assertIsNone(sot.retype(self.sess, 'rbd', 'on-demand')) + + url = 'volumes/%s/action' % FAKE_ID + body = { + 'os-retype': { + 'new_type': 'rbd', + 'migration_policy': 'on-demand' + } + } + headers = {'Accept': ''} + self.sess.post.assert_called_with(url, json=body, headers=headers) From d72e60819d5b117797906eaeaebbe463ade1ea27 Mon Sep 17 00:00:00 2001 From: songwenping Date: Thu, 29 Apr 2021 20:21:56 +0800 Subject: [PATCH 02/16] setup.cfg: Replace dashes with underscores Setuptools v54.1.0 introduces a warning that the use of dash-separated options in 'setup.cfg' will not be supported in a future version [1]. Get ahead of the issue by replacing the dashes with underscores. Without this, we see 'UserWarning' messages like the following on new enough versions of setuptools: UserWarning: Usage of dash-separated 'description-file' will not be supported in future versions. Please use the underscore name 'description_file' instead [1] https://github.com/pypa/setuptools/commit/a2e9ae4cb Change-Id: I6fc527205aa8bc2c226f5649b894b8a1de7525a2 --- setup.cfg | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/setup.cfg b/setup.cfg index a635769c4..0c5f95cde 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,11 +1,11 @@ [metadata] name = openstacksdk summary = An SDK for building applications to work with OpenStack -description-file = +description_file = README.rst author = OpenStack -author-email = openstack-discuss@lists.openstack.org -home-page = https://docs.openstack.org/openstacksdk/ +author_email = openstack-discuss@lists.openstack.org +home_page = https://docs.openstack.org/openstacksdk/ classifier = Environment :: OpenStack Intended Audience :: Information Technology From 722669d05a081e441394461551fed2380e6cf08b Mon Sep 17 00:00:00 2001 From: Dmitriy Rabotyagov Date: Thu, 29 Apr 2021 16:32:23 +0300 Subject: [PATCH 03/16] Adjust image _base_proxy condition It makes no sense in running get_image when image is None. Intended behaviour here would be recieving image object, when we were provided with name or id Change-Id: I2fac79a9c5260405f4602583efce7a4d61af5ed2 --- openstack/image/_base_proxy.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openstack/image/_base_proxy.py b/openstack/image/_base_proxy.py index 7bd75bf3c..1280181d0 100644 --- a/openstack/image/_base_proxy.py +++ b/openstack/image/_base_proxy.py @@ -251,7 +251,7 @@ class BaseImageProxy(proxy.Proxy, metaclass=abc.ABCMeta): converted to int. """ - if image is None: + if isinstance(image, str): image = self._connection.get_image(image) if not meta: From ed566ac2ac6f43a4ee890f51255ddfc256bf38ff Mon Sep 17 00:00:00 2001 From: Artem Goncharov Date: Thu, 6 May 2021 18:10:45 +0200 Subject: [PATCH 04/16] Add support for project options Options are currently not supported as an attribute of the identity.project. Change-Id: I1a2d7effbf634c0501c36c2b528eb5e3ceff1958 --- openstack/identity/v3/project.py | 3 +++ openstack/tests/unit/identity/v3/test_project.py | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/openstack/identity/v3/project.py b/openstack/identity/v3/project.py index 19fa8dc9d..24ae45635 100644 --- a/openstack/identity/v3/project.py +++ b/openstack/identity/v3/project.py @@ -55,6 +55,9 @@ class Project(resource.Resource, resource.TagMixin): is_enabled = resource.Body('enabled', type=bool) #: Unique project name, within the owning domain. *Type: string* name = resource.Body('name') + #: The resource options for the project. Available resource options are + #: immutable. + options = resource.Body('options', type=dict) #: The ID of the parent of the project. #: New in version 3.4 parent_id = resource.Body('parent_id') diff --git a/openstack/tests/unit/identity/v3/test_project.py b/openstack/tests/unit/identity/v3/test_project.py index 95c0ad22d..9406d5abe 100644 --- a/openstack/tests/unit/identity/v3/test_project.py +++ b/openstack/tests/unit/identity/v3/test_project.py @@ -23,6 +23,9 @@ EXAMPLE = { 'is_domain': False, 'name': '5', 'parent_id': '6', + 'options': { + 'foo': 'bar' + } } @@ -65,6 +68,7 @@ class TestProject(base.TestCase): self.assertEqual(EXAMPLE['id'], sot.id) self.assertEqual(EXAMPLE['name'], sot.name) self.assertEqual(EXAMPLE['parent_id'], sot.parent_id) + self.assertDictEqual(EXAMPLE['options'], sot.options) class TestUserProject(base.TestCase): From bcdeb001d717cb209c3e6a1b19c5ba5b56b7364c Mon Sep 17 00:00:00 2001 From: James Palmer Date: Wed, 28 Apr 2021 18:31:51 +0000 Subject: [PATCH 05/16] Add support for API Extensions Introduct the extensions resource, its attributes, and API Calls for interacting with API Extensions. Task: 41810 Story: 2008619 Signed-off-by: James Palmer Change-Id: Ib45a47ef5563d2ca0690420ec859356ea887447a --- openstack/block_storage/v3/_proxy.py | 10 +++++ openstack/block_storage/v3/extension.py | 31 ++++++++++++++ .../block_storage/v3/test_extension.py | 24 +++++++++++ .../unit/block_storage/v3/test_extension.py | 41 +++++++++++++++++++ .../tests/unit/block_storage/v3/test_proxy.py | 4 ++ 5 files changed, 110 insertions(+) create mode 100644 openstack/block_storage/v3/extension.py create mode 100644 openstack/tests/functional/block_storage/v3/test_extension.py create mode 100644 openstack/tests/unit/block_storage/v3/test_extension.py diff --git a/openstack/block_storage/v3/_proxy.py b/openstack/block_storage/v3/_proxy.py index a62a1a083..ffc9e7b4f 100644 --- a/openstack/block_storage/v3/_proxy.py +++ b/openstack/block_storage/v3/_proxy.py @@ -14,6 +14,7 @@ from openstack.block_storage import _base_proxy from openstack.block_storage.v3 import availability_zone from openstack.block_storage.v3 import backup as _backup from openstack.block_storage.v3 import capabilities as _capabilities +from openstack.block_storage.v3 import extension as _extension from openstack.block_storage.v3 import group_type as _group_type from openstack.block_storage.v3 import limits as _limits from openstack.block_storage.v3 import resource_filter as _resource_filter @@ -693,6 +694,15 @@ class Proxy(_base_proxy.BaseBlockStorageProxy): """ return self._list(_resource_filter.ResourceFilter, **query) + def extensions(self): + """Return a generator of extensions + + :returns: A generator of extension + :rtype: :class:`~openstack.block_storage.v3.extension.\ + Extension` + """ + return self._list(_extension.Extension) + def _get_cleanup_dependencies(self): return { 'block_storage': { diff --git a/openstack/block_storage/v3/extension.py b/openstack/block_storage/v3/extension.py new file mode 100644 index 000000000..e2085e15c --- /dev/null +++ b/openstack/block_storage/v3/extension.py @@ -0,0 +1,31 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from openstack import resource + + +class Extension(resource.Resource): + """Extension""" + resources_key = "extensions" + base_path = "/extensions" + + # Capabilities + allow_list = True + + #: Properties + #: The alias for the extension. + alias = resource.Body('alias', type=str) + #: The extension description. + description = resource.Body('description', type=str) + #: The date and time when the resource was updated. + #: The date and time stamp format is ISO 8601. + updated = resource.Body('updated', type=str) diff --git a/openstack/tests/functional/block_storage/v3/test_extension.py b/openstack/tests/functional/block_storage/v3/test_extension.py new file mode 100644 index 000000000..5ad84feda --- /dev/null +++ b/openstack/tests/functional/block_storage/v3/test_extension.py @@ -0,0 +1,24 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from openstack.tests.functional.block_storage.v3 import base + + +class Extensions(base.BaseBlockStorageTest): + + def test_get(self): + extensions = list(self.conn.block_storage.extensions()) + + for extension in extensions: + self.assertIsInstance(extension.alias, str) + self.assertIsInstance(extension.description, str) + self.assertIsInstance(extension.updated, str) diff --git a/openstack/tests/unit/block_storage/v3/test_extension.py b/openstack/tests/unit/block_storage/v3/test_extension.py new file mode 100644 index 000000000..4d92f67e9 --- /dev/null +++ b/openstack/tests/unit/block_storage/v3/test_extension.py @@ -0,0 +1,41 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# # Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from openstack.block_storage.v3 import extension +from openstack.tests.unit import base + +EXTENSION = { + "alias": "os-hosts", + "description": "Admin-only host administration.", + "links": [], + "name": "Hosts", + "updated": "2011-06-29T00:00:00+00:00", +} + + +class TestExtension(base.TestCase): + + def test_basic(self): + extension_resource = extension.Extension() + self.assertEqual('extensions', extension_resource.resources_key) + self.assertEqual('/extensions', extension_resource.base_path) + self.assertFalse(extension_resource.allow_create) + self.assertFalse(extension_resource.allow_fetch) + self.assertFalse(extension_resource.allow_commit) + self.assertFalse(extension_resource.allow_delete) + self.assertTrue(extension_resource.allow_list) + + def test_make_extension(self): + extension_resource = extension.Extension(**EXTENSION) + self.assertEqual(EXTENSION['alias'], extension_resource.alias) + self.assertEqual(EXTENSION['description'], + extension_resource.description) + self.assertEqual(EXTENSION['updated'], extension_resource.updated) diff --git a/openstack/tests/unit/block_storage/v3/test_proxy.py b/openstack/tests/unit/block_storage/v3/test_proxy.py index a83e5db4e..46c9c3b5f 100644 --- a/openstack/tests/unit/block_storage/v3/test_proxy.py +++ b/openstack/tests/unit/block_storage/v3/test_proxy.py @@ -14,6 +14,7 @@ from unittest import mock from openstack.block_storage.v3 import _proxy from openstack.block_storage.v3 import backup from openstack.block_storage.v3 import capabilities +from openstack.block_storage.v3 import extension from openstack.block_storage.v3 import group_type from openstack.block_storage.v3 import limits from openstack.block_storage.v3 import resource_filter @@ -269,3 +270,6 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): def test_group_type_update(self): self.verify_update(self.proxy.update_group_type, group_type.GroupType) + + def test_extensions(self): + self.verify_list(self.proxy.extensions, extension.Extension) From 6269f8cf9fc472da10d5c7700801fb925f41d215 Mon Sep 17 00:00:00 2001 From: ITD27M01 Date: Sat, 8 May 2021 22:40:04 +0300 Subject: [PATCH 06/16] Fix get_server_password method This change fixes the get_server_password method where a typo (or mistake) prevents making the actual proxy request. Also, we need to process the Response object, check for any exceptions and return encrypted password string - what the user expects. Story: 2008889 Task: 42449 Change-Id: Idcd6f329dcffd87f70771378ddbb686fd95c6184 --- openstack/compute/v2/_proxy.py | 2 +- openstack/compute/v2/server.py | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/openstack/compute/v2/_proxy.py b/openstack/compute/v2/_proxy.py index 16160502a..bb5647cb8 100644 --- a/openstack/compute/v2/_proxy.py +++ b/openstack/compute/v2/_proxy.py @@ -708,7 +708,7 @@ class Proxy(proxy.Proxy): :returns: encrypted password. """ server = self._get_resource(_server.Server, server) - return server.get_password(self._session) + return server.get_password(self) def reset_server_state(self, server, state): """Reset the state of server diff --git a/openstack/compute/v2/server.py b/openstack/compute/v2/server.py index e3ae44a2d..fd5a35b0c 100644 --- a/openstack/compute/v2/server.py +++ b/openstack/compute/v2/server.py @@ -256,7 +256,12 @@ class Server(resource.Resource, metadata.MetadataMixin, resource.TagMixin): def get_password(self, session): """Get the encrypted administrator password.""" url = utils.urljoin(Server.base_path, self.id, 'os-server-password') - return session.get(url) + + response = session.get(url) + exceptions.raise_from_response(response) + + data = response.json() + return data.get('password') def reboot(self, session, reboot_type): """Reboot server where reboot_type might be 'SOFT' or 'HARD'.""" From 3958422a869a1342b313a2d201d10911167c526f Mon Sep 17 00:00:00 2001 From: Artem Goncharov Date: Mon, 10 May 2021 15:59:04 +0200 Subject: [PATCH 07/16] Fix MFA authorization This is absolutely impractical to force users to code TOTP token in the clouds.yaml. With this change it is possible to pass passcode dynamically, what will especially be helping OSC with --os-passcode to pass the MFA code. Change-Id: I2b3b17f13744c05bdafb2367fb45cc6b39845807 --- doc/source/user/config/configuration.rst | 25 ++++++++++++++++++++++ openstack/config/loader.py | 6 ++++++ openstack/tests/unit/config/test_config.py | 23 ++++++++++++++++++++ 3 files changed, 54 insertions(+) diff --git a/doc/source/user/config/configuration.rst b/doc/source/user/config/configuration.rst index 829fd5a03..be420f18f 100644 --- a/doc/source/user/config/configuration.rst +++ b/doc/source/user/config/configuration.rst @@ -262,6 +262,31 @@ establish new connection. auth: true +MFA Support +----------- + +MFA support requires a specially prepared configuration file. In this case a +combination of 2 different authorization plugins is used with their individual +requirements to the specified parameteres. + +.. code-block:: yaml + + clouds: + mfa: + auth_type: "v3multifactor" + auth_methods: + - v3password + - v3totp + auth: + auth_url: https://identity.cloud.com + username: user + user_id: uid + password: XXXXXXXXX + project_name: project + user_domain_name: udn + project_domain_name: pdn + + IPv6 ---- diff --git a/openstack/config/loader.py b/openstack/config/loader.py index c2729654c..c3d04c7a7 100644 --- a/openstack/config/loader.py +++ b/openstack/config/loader.py @@ -1042,6 +1042,12 @@ class OpenStackConfig: or ('token' in config and config['token'])): config.setdefault('token', config.pop('auth_token', None)) + # Infer passcode if it was given separately + # This is generally absolutely impractical to require setting passcode + # in the clouds.yaml + if 'auth' in config and 'passcode' in config: + config['auth']['passcode'] = config.pop('passcode', None) + # These backwards compat values are only set via argparse. If it's # there, it's because it was passed in explicitly, and should win config = self._fix_backwards_api_timeout(config) diff --git a/openstack/tests/unit/config/test_config.py b/openstack/tests/unit/config/test_config.py index 392d566c5..bc31cc2ef 100644 --- a/openstack/tests/unit/config/test_config.py +++ b/openstack/tests/unit/config/test_config.py @@ -205,6 +205,29 @@ class TestConfig(base.TestCase): self.assertNotIn('domain_id', cc.auth) self.assertNotIn('domain_id', cc) + def test_get_one_infer_passcode(self): + single_conf = base._write_yaml({ + 'clouds': { + 'mfa': { + 'auth_type': 'v3multifactor', + 'auth_methods': ['v3password', 'v3totp'], + 'auth': { + 'auth_url': 'fake_url', + 'username': 'testuser', + 'password': 'testpass', + 'project_name': 'testproject', + 'project_domain_name': 'projectdomain', + 'user_domain_name': 'udn' + }, + 'region_name': 'test-region', + } + } + }) + + c = config.OpenStackConfig(config_files=[single_conf]) + cc = c.get_one(cloud='mfa', passcode='123') + self.assertEqual('123', cc.auth['passcode']) + def test_get_one_with_hyphenated_project_id(self): c = config.OpenStackConfig(config_files=[self.cloud_yaml], vendor_files=[self.vendor_yaml]) From 38e9ca0090247bee1b999d39634fa8fd6503b7ae Mon Sep 17 00:00:00 2001 From: Stephen Finucane Date: Thu, 25 Mar 2021 12:39:37 +0000 Subject: [PATCH 08/16] placement: Add support for resource classes This one is simple. Resource classes are just strings: { "name": "CUSTOM_FPGA", } Change-Id: Ic47a52b329af5f2ca265ac3c307c33fe8ca42ef2 Signed-off-by: Stephen Finucane --- doc/source/user/proxies/placement.rst | 10 ++- doc/source/user/resources/placement/index.rst | 1 + .../resources/placement/v1/resource_class.rst | 13 +++ openstack/placement/v1/_proxy.py | 84 ++++++++++++++++++- openstack/placement/v1/resource_class.py | 32 +++++++ .../tests/unit/placement/v1/test_proxy.py | 37 ++++++++ .../unit/placement/v1/test_resource_class.py | 42 ++++++++++ ...ement-resource-class-e1c644d978b886bc.yaml | 4 + 8 files changed, 221 insertions(+), 2 deletions(-) create mode 100644 doc/source/user/resources/placement/v1/resource_class.rst create mode 100644 openstack/placement/v1/resource_class.py create mode 100644 openstack/tests/unit/placement/v1/test_resource_class.py create mode 100644 releasenotes/notes/add-placement-resource-class-e1c644d978b886bc.yaml diff --git a/doc/source/user/proxies/placement.rst b/doc/source/user/proxies/placement.rst index 0cc3f8974..b9978e7d1 100644 --- a/doc/source/user/proxies/placement.rst +++ b/doc/source/user/proxies/placement.rst @@ -10,6 +10,14 @@ The placement high-level interface is available through the ``placement`` member of a :class:`~openstack.connection.Connection` object. The ``placement`` member will only be added if the service is detected. +Resource Classes +^^^^^^^^^^^^^^^^ + +.. autoclass:: openstack.placement.v1._proxy.Proxy + :noindex: + :members: create_resource_class, update_resource_class, + delete_resource_class, get_resource_class, + resource_classes Resource Providers ^^^^^^^^^^^^^^^^^^ @@ -18,4 +26,4 @@ Resource Providers :noindex: :members: create_resource_provider, update_resource_provider, delete_resource_provider, get_resource_provider, - resource_providers + find_resource_provider, resource_providers diff --git a/doc/source/user/resources/placement/index.rst b/doc/source/user/resources/placement/index.rst index 7f581b9bb..5d8180cd9 100644 --- a/doc/source/user/resources/placement/index.rst +++ b/doc/source/user/resources/placement/index.rst @@ -4,4 +4,5 @@ Placement v1 Resources .. toctree:: :maxdepth: 1 + v1/resource_class v1/resource_provider diff --git a/doc/source/user/resources/placement/v1/resource_class.rst b/doc/source/user/resources/placement/v1/resource_class.rst new file mode 100644 index 000000000..2ef5817b9 --- /dev/null +++ b/doc/source/user/resources/placement/v1/resource_class.rst @@ -0,0 +1,13 @@ +openstack.placement.v1.resource_class +===================================== + +.. automodule:: openstack.placement.v1.resource_class + +The ResourceClass Class +----------------------- + +The ``ResourceClass`` class inherits from +:class:`~openstack.resource.Resource`. + +.. autoclass:: openstack.placement.v1.resource_class.ResourceClass + :members: diff --git a/openstack/placement/v1/_proxy.py b/openstack/placement/v1/_proxy.py index 9f222afef..a8ac8f26a 100644 --- a/openstack/placement/v1/_proxy.py +++ b/openstack/placement/v1/_proxy.py @@ -10,12 +10,94 @@ # License for the specific language governing permissions and limitations # under the License. +from openstack.placement.v1 import resource_class as _resource_class from openstack.placement.v1 import resource_provider as _resource_provider from openstack import proxy class Proxy(proxy.Proxy): + # resource classes + + def create_resource_class(self, **attrs): + """Create a new resource class from attributes. + + :param attrs: Keyword arguments which will be used to create a + :class:`~openstack.placement.v1.resource_provider.ResourceClass`, + comprised of the properties on the ResourceClass class. + + :returns: The results of resource class creation + :rtype: :class:`~openstack.placement.v1.resource_class.ResourceClass` + """ + return self._create(_resource_class.ResourceClass, **attrs) + + def delete_resource_class(self, resource_class, ignore_missing=True): + """Delete a resource class + + :param resource_class: The value can be either the ID of a resource + class or an + :class:`~openstack.placement.v1.resource_class.ResourceClass`, + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be raised when + the resource class does not exist. When set to ``True``, no + exception will be set when attempting to delete a nonexistent + resource class. + + :returns: ``None`` + """ + self._delete( + _resource_class.ResourceClass, + resource_class, + ignore_missing=ignore_missing, + ) + + def update_resource_class(self, resource_class, **attrs): + """Update a resource class + + :param resource_class: The value can be either the ID of a resource + class or an + :class:`~openstack.placement.v1.resource_class.ResourceClass`, + instance. + :attrs kwargs: The attributes to update on the resource class + represented by ``resource_class``. + + :returns: The updated resource class + :rtype: :class:`~openstack.placement.v1.resource_class.ResourceClass` + """ + return self._update( + _resource_class.ResourceClass, resource_class, **attrs, + ) + + def get_resource_class(self, resource_class): + """Get a single resource_class. + + :param resource_class: The value can be either the ID of a resource + class or an + :class:`~openstack.placement.v1.resource_class.ResourceClass`, + instance. + + :returns: An instance of + :class:`~openstack.placement.v1.resource_class.ResourceClass` + :raises: :class:`~openstack.exceptions.ResourceNotFound` when no + resource class matching the criteria could be found. + """ + return self._get( + _resource_class.ResourceClass, resource_class, + ) + + def resource_classes(self, **query): + """Retrieve a generator of resource classs. + + :param kwargs query: Optional query parameters to be sent to + restrict the resource classs to be returned. + + :returns: A generator of resource class instances. + """ + return self._list(_resource_class.ResourceClass, **query) + + # resource providers + def create_resource_provider(self, **attrs): """Create a new resource provider from attributes. @@ -50,7 +132,7 @@ class Proxy(proxy.Proxy): ) def update_resource_provider(self, resource_provider, **attrs): - """Update a flavor + """Update a resource provider :param resource_provider: The value can be either the ID of a resource provider or an diff --git a/openstack/placement/v1/resource_class.py b/openstack/placement/v1/resource_class.py new file mode 100644 index 000000000..e45f5e642 --- /dev/null +++ b/openstack/placement/v1/resource_class.py @@ -0,0 +1,32 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from openstack import resource + + +class ResourceClass(resource.Resource): + resource_key = None + resources_key = 'resource_classes' + base_path = '/resource_classes' + + # Capabilities + + allow_create = True + allow_fetch = True + allow_commit = True + allow_delete = True + allow_list = True + + # Added in 1.2 + _max_microversion = '1.2' + + name = resource.Body('name', alternate_id=True) diff --git a/openstack/tests/unit/placement/v1/test_proxy.py b/openstack/tests/unit/placement/v1/test_proxy.py index 210704f09..1b915c0e9 100644 --- a/openstack/tests/unit/placement/v1/test_proxy.py +++ b/openstack/tests/unit/placement/v1/test_proxy.py @@ -11,6 +11,7 @@ # under the License. from openstack.placement.v1 import _proxy +from openstack.placement.v1 import resource_class from openstack.placement.v1 import resource_provider from openstack.tests.unit import test_proxy_base as test_proxy_base @@ -21,6 +22,42 @@ class TestPlacementProxy(test_proxy_base.TestProxyBase): super().setUp() self.proxy = _proxy.Proxy(self.session) + # resource classes + + def test_resource_class_create(self): + self.verify_create( + self.proxy.create_resource_class, + resource_class.ResourceClass, + ) + + def test_resource_class_delete(self): + self.verify_delete( + self.proxy.delete_resource_class, + resource_class.ResourceClass, + False, + ) + + def test_resource_class_update(self): + self.verify_update( + self.proxy.update_resource_class, + resource_class.ResourceClass, + False, + ) + + def test_resource_class_get(self): + self.verify_get( + self.proxy.get_resource_class, + resource_class.ResourceClass, + ) + + def test_resource_classes(self): + self.verify_list_no_kwargs( + self.proxy.resource_classes, + resource_class.ResourceClass, + ) + + # resource providers + def test_resource_provider_create(self): self.verify_create( self.proxy.create_resource_provider, diff --git a/openstack/tests/unit/placement/v1/test_resource_class.py b/openstack/tests/unit/placement/v1/test_resource_class.py new file mode 100644 index 000000000..9114dec34 --- /dev/null +++ b/openstack/tests/unit/placement/v1/test_resource_class.py @@ -0,0 +1,42 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from openstack.placement.v1 import resource_class as rc +from openstack.tests.unit import base + +FAKE = { + 'name': 'CUSTOM_FPGA', +} + + +class TestResourceClass(base.TestCase): + + def test_basic(self): + sot = rc.ResourceClass() + self.assertEqual(None, sot.resource_key) + self.assertEqual('resource_classes', sot.resources_key) + self.assertEqual('/resource_classes', sot.base_path) + self.assertTrue(sot.allow_create) + self.assertTrue(sot.allow_fetch) + self.assertTrue(sot.allow_commit) + self.assertTrue(sot.allow_delete) + self.assertTrue(sot.allow_list) + self.assertFalse(sot.allow_patch) + + self.assertDictEqual( + {'limit': 'limit', 'marker': 'marker'}, + sot._query_mapping._mapping) + + def test_make_it(self): + sot = rc.ResourceClass(**FAKE) + self.assertEqual(FAKE['name'], sot.id) + self.assertEqual(FAKE['name'], sot.name) diff --git a/releasenotes/notes/add-placement-resource-class-e1c644d978b886bc.yaml b/releasenotes/notes/add-placement-resource-class-e1c644d978b886bc.yaml new file mode 100644 index 000000000..c3631abde --- /dev/null +++ b/releasenotes/notes/add-placement-resource-class-e1c644d978b886bc.yaml @@ -0,0 +1,4 @@ +--- +features: + - | + Added support for the ``ResourceClass`` Placement resource. From 5edbb15e252c53aa9bcd11245e9b554d2cfa4f92 Mon Sep 17 00:00:00 2001 From: Stephen Finucane Date: Fri, 23 Apr 2021 14:34:30 +0100 Subject: [PATCH 09/16] tests: Remove dead code There are no references to 'openstack.tests.unit.test_proxy_base2' since change I5d288c25797833a850b361af8f067923b00b8706. Change-Id: Iad4122c83d4394dbf1761eeb6d83ccdee9723f52 Signed-off-by: Stephen Finucane --- openstack/tests/unit/test_proxy_base2.py | 234 ----------------------- 1 file changed, 234 deletions(-) delete mode 100644 openstack/tests/unit/test_proxy_base2.py diff --git a/openstack/tests/unit/test_proxy_base2.py b/openstack/tests/unit/test_proxy_base2.py deleted file mode 100644 index 56b8927af..000000000 --- a/openstack/tests/unit/test_proxy_base2.py +++ /dev/null @@ -1,234 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -from unittest import mock - -from openstack.tests.unit import base - - -class TestProxyBase(base.TestCase): - # object_store makes calls with container= rather than - # path_args=dict(container= because container needs to wind up - # in the uri components. - kwargs_to_path_args = True - - def setUp(self): - super(TestProxyBase, self).setUp() - self.session = mock.Mock() - - def _add_path_args_for_verify(self, path_args, method_args, - expected_kwargs, value=None): - if path_args is not None: - if value is None: - for key in path_args: - method_args.append(path_args[key]) - expected_kwargs['path_args'] = path_args - - def _verify(self, mock_method, test_method, - method_args=None, method_kwargs=None, - expected_args=None, expected_kwargs=None, - expected_result=None): - with mock.patch(mock_method) as mocked: - mocked.return_value = expected_result - if any([method_args, method_kwargs, - expected_args, expected_kwargs]): - method_args = method_args or () - method_kwargs = method_kwargs or {} - expected_args = expected_args or () - expected_kwargs = expected_kwargs or {} - - self.assertEqual(expected_result, test_method(*method_args, - **method_kwargs)) - mocked.assert_called_with(test_method.__self__, - *expected_args, **expected_kwargs) - else: - self.assertEqual(expected_result, test_method()) - mocked.assert_called_with(test_method.__self__) - - # NOTE(briancurtin): This is a duplicate version of _verify that is - # temporarily here while we shift APIs. The difference is that - # calls from the Proxy classes aren't going to be going directly into - # the Resource layer anymore, so they don't pass in the session which - # was tested in assert_called_with. - # This is being done in lieu of adding logic and complicating - # the _verify method. It will be removed once there is one API to - # be verifying. - def _verify2(self, mock_method, test_method, - method_args=None, method_kwargs=None, method_result=None, - expected_args=None, expected_kwargs=None, - expected_result=None): - with mock.patch(mock_method) as mocked: - mocked.return_value = expected_result - if any([method_args, method_kwargs, - expected_args, expected_kwargs]): - method_args = method_args or () - method_kwargs = method_kwargs or {} - expected_args = expected_args or () - expected_kwargs = expected_kwargs or {} - - if method_result: - self.assertEqual(method_result, test_method(*method_args, - **method_kwargs)) - else: - self.assertEqual(expected_result, test_method(*method_args, - **method_kwargs)) - mocked.assert_called_with(*expected_args, **expected_kwargs) - else: - self.assertEqual(expected_result, test_method()) - mocked.assert_called_with(test_method.__self__) - - def verify_create(self, test_method, resource_type, - mock_method="openstack.proxy.Proxy._create", - expected_result="result", **kwargs): - the_kwargs = {"x": 1, "y": 2, "z": 3} - method_kwargs = kwargs.pop("method_kwargs", the_kwargs) - expected_args = [resource_type] - expected_kwargs = kwargs.pop("expected_kwargs", the_kwargs) - - self._verify2(mock_method, test_method, - expected_result=expected_result, - method_kwargs=method_kwargs, - expected_args=expected_args, - expected_kwargs=expected_kwargs, - **kwargs) - - def verify_delete(self, test_method, resource_type, ignore, - input_path_args=None, expected_path_args=None, - method_kwargs=None, expected_args=None, - expected_kwargs=None, - mock_method="openstack.proxy.Proxy._delete"): - method_args = ["resource_or_id"] - method_kwargs = method_kwargs or {} - method_kwargs["ignore_missing"] = ignore - if isinstance(input_path_args, dict): - for key in input_path_args: - method_kwargs[key] = input_path_args[key] - elif isinstance(input_path_args, list): - method_args = input_path_args - expected_kwargs = expected_kwargs or {} - expected_kwargs["ignore_missing"] = ignore - if expected_path_args: - expected_kwargs.update(expected_path_args) - expected_args = expected_args or [resource_type, "resource_or_id"] - self._verify2(mock_method, test_method, - method_args=method_args, - method_kwargs=method_kwargs, - expected_args=expected_args, - expected_kwargs=expected_kwargs) - - def verify_get(self, test_method, resource_type, value=None, args=None, - mock_method="openstack.proxy.Proxy._get", - ignore_value=False, **kwargs): - the_value = value - if value is None: - the_value = [] if ignore_value else ["value"] - expected_args = kwargs.pop("expected_args", []) - expected_kwargs = kwargs.pop("expected_kwargs", {}) - method_kwargs = kwargs.pop("method_kwargs", kwargs) - if args: - expected_kwargs["args"] = args - if kwargs and self.kwargs_to_path_args: - expected_kwargs["path_args"] = kwargs - if not expected_args: - expected_args = [resource_type] + the_value - self._verify2(mock_method, test_method, - method_args=the_value, - method_kwargs=method_kwargs or {}, - expected_args=expected_args, - expected_kwargs=expected_kwargs) - - def verify_head(self, test_method, resource_type, - mock_method="openstack.proxy.Proxy._head", - value=None, **kwargs): - the_value = [value] if value is not None else [] - if self.kwargs_to_path_args: - expected_kwargs = {"path_args": kwargs} if kwargs else {} - else: - expected_kwargs = kwargs or {} - self._verify2(mock_method, test_method, - method_args=the_value, - method_kwargs=kwargs, - expected_args=[resource_type] + the_value, - expected_kwargs=expected_kwargs) - - def verify_find(self, test_method, resource_type, value=None, - mock_method="openstack.proxy.Proxy._find", - path_args=None, **kwargs): - method_args = value or ["name_or_id"] - expected_kwargs = {} - - self._add_path_args_for_verify(path_args, method_args, expected_kwargs, - value=value) - - # TODO(briancurtin): if sub-tests worked in this mess of - # test dependencies, the following would be a lot easier to work with. - expected_kwargs["ignore_missing"] = False - self._verify2(mock_method, test_method, - method_args=method_args + [False], - expected_args=[resource_type, "name_or_id"], - expected_kwargs=expected_kwargs, - expected_result="result", - **kwargs) - - expected_kwargs["ignore_missing"] = True - self._verify2(mock_method, test_method, - method_args=method_args + [True], - expected_args=[resource_type, "name_or_id"], - expected_kwargs=expected_kwargs, - expected_result="result", - **kwargs) - - def verify_list(self, test_method, resource_type, paginated=False, - mock_method="openstack.proxy.Proxy._list", - **kwargs): - expected_kwargs = kwargs.pop("expected_kwargs", {}) - expected_kwargs.update({"paginated": paginated}) - method_kwargs = kwargs.pop("method_kwargs", {}) - self._verify2(mock_method, test_method, - method_kwargs=method_kwargs, - expected_args=[resource_type], - expected_kwargs=expected_kwargs, - expected_result=["result"], - **kwargs) - - def verify_list_no_kwargs(self, test_method, resource_type, - paginated=False, - mock_method="openstack.proxy.Proxy._list"): - self._verify2(mock_method, test_method, - method_kwargs={}, - expected_args=[resource_type], - expected_kwargs={"paginated": paginated}, - expected_result=["result"]) - - def verify_update(self, test_method, resource_type, value=None, - mock_method="openstack.proxy.Proxy._update", - expected_result="result", path_args=None, **kwargs): - method_args = value or ["resource_or_id"] - method_kwargs = {"x": 1, "y": 2, "z": 3} - expected_args = kwargs.pop("expected_args", ["resource_or_id"]) - expected_kwargs = method_kwargs.copy() - - self._add_path_args_for_verify(path_args, method_args, expected_kwargs, - value=value) - - self._verify2(mock_method, test_method, - expected_result=expected_result, - method_args=method_args, - method_kwargs=method_kwargs, - expected_args=[resource_type] + expected_args, - expected_kwargs=expected_kwargs, - **kwargs) - - def verify_wait_for_status( - self, test_method, - mock_method="openstack.resource.wait_for_status", **kwargs): - self._verify(mock_method, test_method, **kwargs) From 2e726ef772fc0dc60a883f63b11078c2b82a68c3 Mon Sep 17 00:00:00 2001 From: Stephen Finucane Date: Fri, 23 Apr 2021 14:48:45 +0100 Subject: [PATCH 10/16] tests: Sanity check 'test_proxy_base' A lot of things have been tacked on here over the years. Normalize things and make it a little easier to grok. Change-Id: I09da8af13ac7721a9d9b3a107babf3590a3975e4 Signed-off-by: Stephen Finucane --- openstack/baremetal/v1/_proxy.py | 9 +- openstack/block_storage/v2/_proxy.py | 7 +- openstack/block_storage/v3/_proxy.py | 7 +- openstack/clustering/v1/_proxy.py | 4 +- openstack/compute/v2/_proxy.py | 12 +- openstack/image/v2/_proxy.py | 22 +- openstack/proxy.py | 19 +- .../tests/unit/block_storage/v3/test_proxy.py | 7 +- .../tests/unit/clustering/v1/test_proxy.py | 4 +- openstack/tests/unit/compute/v2/test_proxy.py | 51 +-- .../tests/unit/database/v1/test_proxy.py | 27 +- openstack/tests/unit/dns/v2/test_proxy.py | 6 +- openstack/tests/unit/image/v2/test_proxy.py | 2 +- .../tests/unit/instance_ha/v1/test_proxy.py | 4 +- .../tests/unit/load_balancer/v2/__init__.py | 0 .../unit/load_balancer/{ => v2}/test_proxy.py | 23 +- openstack/tests/unit/message/v2/test_proxy.py | 43 ++- openstack/tests/unit/network/v2/test_proxy.py | 139 +++++--- .../tests/unit/object_store/v1/test_proxy.py | 9 +- .../tests/unit/orchestration/v1/test_proxy.py | 10 +- .../tests/unit/placement/v1/test_proxy.py | 4 +- openstack/tests/unit/test_proxy_base.py | 318 ++++++++++-------- openstack/tests/unit/workflow/v2/__init__.py | 0 .../unit/workflow/{ => v2}/test_proxy.py | 0 24 files changed, 427 insertions(+), 300 deletions(-) create mode 100644 openstack/tests/unit/load_balancer/v2/__init__.py rename openstack/tests/unit/load_balancer/{ => v2}/test_proxy.py (96%) create mode 100644 openstack/tests/unit/workflow/v2/__init__.py rename openstack/tests/unit/workflow/{ => v2}/test_proxy.py (100%) diff --git a/openstack/baremetal/v1/_proxy.py b/openstack/baremetal/v1/_proxy.py index 2cbda567b..0b9e21413 100644 --- a/openstack/baremetal/v1/_proxy.py +++ b/openstack/baremetal/v1/_proxy.py @@ -168,19 +168,20 @@ class Proxy(proxy.Proxy): return self._delete(_chassis.Chassis, chassis, ignore_missing=ignore_missing) - def drivers(self, details=False): + def drivers(self, details=False, **query): """Retrieve a generator of drivers. :param bool details: A boolean indicating whether the detailed information for every driver should be returned. + :param kwargs query: Optional query parameters to be sent to limit + the resources being returned. :returns: A generator of driver instances. """ - kwargs = {} # NOTE(dtantsur): details are available starting with API microversion # 1.30. Thus we do not send any value if not needed. if details: - kwargs['details'] = True - return self._list(_driver.Driver, **kwargs) + query['details'] = True + return self._list(_driver.Driver, **query) def get_driver(self, driver): """Get a specific driver. diff --git a/openstack/block_storage/v2/_proxy.py b/openstack/block_storage/v2/_proxy.py index fb2eb0ded..212e0220c 100644 --- a/openstack/block_storage/v2/_proxy.py +++ b/openstack/block_storage/v2/_proxy.py @@ -201,12 +201,15 @@ class Proxy(_base_proxy.BaseBlockStorageProxy): volume = self._get_resource(_volume.Volume, volume) volume.extend(self, size) - def backend_pools(self): + def backend_pools(self, **query): """Returns a generator of cinder Back-end storage pools + :param kwargs query: Optional query parameters to be sent to limit + the resources being returned. + :returns A generator of cinder Back-end storage pools objects """ - return self._list(_stats.Pools) + return self._list(_stats.Pools, **query) def backups(self, details=True, **query): """Retrieve a generator of backups diff --git a/openstack/block_storage/v3/_proxy.py b/openstack/block_storage/v3/_proxy.py index a62a1a083..ee601385f 100644 --- a/openstack/block_storage/v3/_proxy.py +++ b/openstack/block_storage/v3/_proxy.py @@ -416,12 +416,15 @@ class Proxy(_base_proxy.BaseBlockStorageProxy): volume = self._get_resource(_volume.Volume, volume) volume.retype(self, new_type, migration_policy) - def backend_pools(self): + def backend_pools(self, **query): """Returns a generator of cinder Back-end storage pools + :param kwargs query: Optional query parameters to be sent to limit + the resources being returned. + :returns A generator of cinder Back-end storage pools objects """ - return self._list(_stats.Pools) + return self._list(_stats.Pools, **query) def backups(self, details=True, **query): """Retrieve a generator of backups diff --git a/openstack/clustering/v1/_proxy.py b/openstack/clustering/v1/_proxy.py index 89dc7507c..51f877295 100644 --- a/openstack/clustering/v1/_proxy.py +++ b/openstack/clustering/v1/_proxy.py @@ -420,12 +420,14 @@ class Proxy(proxy.Proxy): obj = self._find(_cluster.Cluster, cluster, ignore_missing=False) return obj.policy_update(self, policy, **params) - def collect_cluster_attrs(self, cluster, path): + def collect_cluster_attrs(self, cluster, path, **query): """Collect attribute values across a cluster. :param cluster: The value can be either the ID of a cluster or a :class:`~openstack.clustering.v1.cluster.Cluster` instance. :param path: A Json path string specifying the attribute to collect. + :param query: Optional query parameters to be sent to limit the + resources being returned. :returns: A dictionary containing the list of attribute values. """ diff --git a/openstack/compute/v2/_proxy.py b/openstack/compute/v2/_proxy.py index 16160502a..a6a7fb321 100644 --- a/openstack/compute/v2/_proxy.py +++ b/openstack/compute/v2/_proxy.py @@ -1144,6 +1144,8 @@ class Proxy(proxy.Proxy): return self._create(_server_interface.ServerInterface, server_id=server_id, **attrs) + # TODO(stephenfin): Does this work? There's no 'value' parameter for the + # call to '_delete' def delete_server_interface(self, server_interface, server=None, ignore_missing=True): """Delete a server interface @@ -1169,7 +1171,7 @@ class Proxy(proxy.Proxy): server_interface = resource.Resource._get_id(server_interface) self._delete(_server_interface.ServerInterface, - port_id=server_interface, + server_interface, server_id=server_id, ignore_missing=ignore_missing) @@ -1197,18 +1199,20 @@ class Proxy(proxy.Proxy): return self._get(_server_interface.ServerInterface, server_id=server_id, port_id=server_interface) - def server_interfaces(self, server): + def server_interfaces(self, server, **query): """Return a generator of server interfaces :param server: The server can be either the ID of a server or a - :class:`~openstack.compute.v2.server.Server`. + :class:`~openstack.compute.v2.server.Server`. + :param query: Optional query parameters to be sent to limit the + resources being returned. :returns: A generator of ServerInterface objects :rtype: :class:`~openstack.compute.v2.server_interface.ServerInterface` """ server_id = resource.Resource._get_id(server) return self._list(_server_interface.ServerInterface, - server_id=server_id) + server_id=server_id, **query) def server_ips(self, server, network_label=None): """Return a generator of server IPs diff --git a/openstack/image/v2/_proxy.py b/openstack/image/v2/_proxy.py index a11e08f6f..72da40b52 100644 --- a/openstack/image/v2/_proxy.py +++ b/openstack/image/v2/_proxy.py @@ -579,16 +579,18 @@ class Proxy(_base_proxy.BaseImageProxy): image_id = resource.Resource._get_id(image) return self._create(_member.Member, image_id=image_id, **attrs) - def remove_member(self, member, image, ignore_missing=True): + def remove_member(self, member, image=None, ignore_missing=True): """Delete a member :param member: The value can be either the ID of a member or a - :class:`~openstack.image.v2.member.Member` instance. + :class:`~openstack.image.v2.member.Member` instance. + :param image: The value can be either the ID of an image or a + :class:`~openstack.image.v2.image.Image` instance that the member + is part of. This is required if ``member`` is an ID. :param bool ignore_missing: When set to ``False`` - :class:`~openstack.exceptions.ResourceNotFound` will be - raised when the member does not exist. - When set to ``True``, no exception will be set when - attempting to delete a nonexistent member. + :class:`~openstack.exceptions.ResourceNotFound` will be raised when + the member does not exist. When set to ``True``, no exception will + be set when attempting to delete a nonexistent member. :returns: ``None`` """ @@ -632,12 +634,14 @@ class Proxy(_base_proxy.BaseImageProxy): return self._get(_member.Member, member_id=member_id, image_id=image_id) - def members(self, image): + def members(self, image, **query): """Return a generator of members :param image: This is the image that the member belongs to, - the value can be the ID of a image or a - :class:`~openstack.image.v2.image.Image` instance. + the value can be the ID of a image or a + :class:`~openstack.image.v2.image.Image` instance. + :param kwargs query: Optional query parameters to be sent to limit + the resources being returned. :returns: A generator of member objects :rtype: :class:`~openstack.image.v2.member.Member` diff --git a/openstack/proxy.py b/openstack/proxy.py index 202628b65..235b5c132 100644 --- a/openstack/proxy.py +++ b/openstack/proxy.py @@ -310,14 +310,13 @@ class Proxy(adapter.Adapter): """Get a resource object to work on :param resource_type: The type of resource to operate on. This should - be a subclass of - :class:`~openstack.resource.Resource` with a - ``from_id`` method. + be a subclass of :class:`~openstack.resource.Resource` with a + ``from_id`` method. :param value: The ID of a resource or an object of ``resource_type`` - class if using an existing instance, or ``munch.Munch``, - or None to create a new instance. - :param path_args: A dict containing arguments for forming the request - URL, if needed. + class if using an existing instance, or ``munch.Munch``, + or None to create a new instance. + :param attrs: A dict containing arguments for forming the request + URL, if needed. """ conn = self._get_connection() if value is None: @@ -374,6 +373,7 @@ class Proxy(adapter.Adapter): ignore_missing=ignore_missing, **attrs) + # TODO(stephenfin): Update docstring for attrs since it's a lie @_check_resource(strict=False) def _delete(self, resource_type, value, ignore_missing=True, **attrs): """Delete a resource @@ -512,16 +512,13 @@ class Proxy(adapter.Adapter): error_message="No {resource_type} found for {value}".format( resource_type=resource_type.__name__, value=value)) - def _list(self, resource_type, value=None, + def _list(self, resource_type, paginated=True, base_path=None, **attrs): """List a resource :param resource_type: The type of resource to list. This should be a :class:`~openstack.resource.Resource` subclass with a ``from_id`` method. - :param value: The resource to list. It can be the ID of a resource, or - a :class:`~openstack.resource.Resource` object. When set - to None, a new bare resource is created. :param bool paginated: When set to ``False``, expect all of the data to be returned in one response. When set to ``True``, the resource supports data being diff --git a/openstack/tests/unit/block_storage/v3/test_proxy.py b/openstack/tests/unit/block_storage/v3/test_proxy.py index a83e5db4e..c6a949f4d 100644 --- a/openstack/tests/unit/block_storage/v3/test_proxy.py +++ b/openstack/tests/unit/block_storage/v3/test_proxy.py @@ -103,9 +103,9 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): def test_type_encryption_get(self): self.verify_get(self.proxy.get_type_encryption, type.TypeEncryption, - expected_args=[type.TypeEncryption], + expected_args=[], expected_kwargs={ - 'volume_type_id': 'value', + 'volume_type_id': 'resource_id', 'requires_id': False }) @@ -237,7 +237,8 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): def test_limits_get(self): self.verify_get( - self.proxy.get_limits, limits.Limit, ignore_value=True, + self.proxy.get_limits, limits.Limit, + method_args=[], expected_kwargs={'requires_id': False}) def test_capabilites_get(self): diff --git a/openstack/tests/unit/clustering/v1/test_proxy.py b/openstack/tests/unit/clustering/v1/test_proxy.py index 07743a4c2..360b6447a 100644 --- a/openstack/tests/unit/clustering/v1/test_proxy.py +++ b/openstack/tests/unit/clustering/v1/test_proxy.py @@ -37,7 +37,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_build_info_get(self): self.verify_get(self.proxy.get_build_info, build_info.BuildInfo, - ignore_value=True, + method_args=[], expected_kwargs={'requires_id': False}) def test_profile_types(self): @@ -137,6 +137,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.collect_cluster_attrs, cluster_attr.ClusterAttr, method_args=['FAKE_ID', 'path.to.attr'], + expected_args=[], expected_kwargs={'cluster_id': 'FAKE_ID', 'path': 'path.to.attr'}) @@ -265,6 +266,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.cluster_policies, cluster_policy.ClusterPolicy, method_args=["FAKE_CLUSTER"], + expected_args=[], expected_kwargs={"cluster_id": "FAKE_CLUSTER"}) def test_get_cluster_policy(self): diff --git a/openstack/tests/unit/compute/v2/test_proxy.py b/openstack/tests/unit/compute/v2/test_proxy.py index 4a4c05ddf..b7d2c1455 100644 --- a/openstack/tests/unit/compute/v2/test_proxy.py +++ b/openstack/tests/unit/compute/v2/test_proxy.py @@ -56,7 +56,7 @@ class TestFlavor(TestComputeProxy): self.verify_find( self.proxy.find_flavor, flavor.Flavor, method_kwargs={"a": "b"}, - expected_kwargs={"a": "b", "ignore_missing": False} + expected_kwargs={"a": "b", "ignore_missing": True} ) def test_flavor_find_fetch_extra(self): @@ -286,7 +286,7 @@ class TestKeyPair(TestComputeProxy): ) def test_keypairs(self): - self.verify_list_no_kwargs(self.proxy.keypairs, keypair.Keypair) + self.verify_list(self.proxy.keypairs, keypair.Keypair) def test_keypairs_user_id(self): self.verify_list( @@ -312,7 +312,7 @@ class TestAggregate(TestComputeProxy): self.verify_find(self.proxy.find_aggregate, aggregate.Aggregate) def test_aggregates(self): - self.verify_list_no_kwargs(self.proxy.aggregates, aggregate.Aggregate) + self.verify_list(self.proxy.aggregates, aggregate.Aggregate) def test_aggregate_get(self): self.verify_get(self.proxy.get_aggregate, aggregate.Aggregate) @@ -355,8 +355,7 @@ class TestAggregate(TestComputeProxy): class TestService(TestComputeProxy): def test_services(self): - self.verify_list_no_kwargs( - self.proxy.services, service.Service) + self.verify_list(self.proxy.services, service.Service) @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=False) @@ -450,11 +449,13 @@ class TestHypervisor(TestComputeProxy): def test_hypervisors_not_detailed(self): self.verify_list(self.proxy.hypervisors, hypervisor.Hypervisor, - method_kwargs={"details": False}) + method_kwargs={"details": False}, + expected_kwargs={}) def test_hypervisors_detailed(self): self.verify_list(self.proxy.hypervisors, hypervisor.HypervisorDetail, - method_kwargs={"details": True}) + method_kwargs={"details": True}, + expected_kwargs={}) @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=False) @@ -462,8 +463,9 @@ class TestHypervisor(TestComputeProxy): self.verify_list( self.proxy.hypervisors, hypervisor.Hypervisor, + base_path='/os-hypervisors/detail', method_kwargs={'details': True}, - base_path='/os-hypervisors/detail' + expected_kwargs={}, ) @mock.patch('openstack.utils.supports_microversion', autospec=True, @@ -472,8 +474,9 @@ class TestHypervisor(TestComputeProxy): self.verify_list( self.proxy.hypervisors, hypervisor.Hypervisor, + base_path='/os-hypervisors/substring/search', method_kwargs={'hypervisor_hostname_pattern': 'substring'}, - base_path='/os-hypervisors/substring/search' + expected_kwargs={}, ) @mock.patch('openstack.utils.supports_microversion', autospec=True, @@ -492,7 +495,7 @@ class TestHypervisor(TestComputeProxy): hypervisor.Hypervisor, expected_kwargs={ 'list_base_path': '/os-hypervisors/detail', - 'ignore_missing': False}) + 'ignore_missing': True}) def test_find_hypervisor_no_detail(self): self.verify_find(self.proxy.find_hypervisor, @@ -500,7 +503,7 @@ class TestHypervisor(TestComputeProxy): method_kwargs={'details': False}, expected_kwargs={ 'list_base_path': None, - 'ignore_missing': False}) + 'ignore_missing': True}) def test_get_hypervisor(self): self.verify_get(self.proxy.get_hypervisor, @@ -519,7 +522,7 @@ class TestCompute(TestComputeProxy): self.verify_find(self.proxy.find_extension, extension.Extension) def test_extensions(self): - self.verify_list_no_kwargs(self.proxy.extensions, extension.Extension) + self.verify_list(self.proxy.extensions, extension.Extension) def test_image_delete(self): self.verify_delete(self.proxy.delete_image, image.Image, False) @@ -544,7 +547,7 @@ class TestCompute(TestComputeProxy): expected_kwargs={"query": 1}) def test_limits_get(self): - self.verify_get(self.proxy.get_limits, limits.Limits, value=[]) + self.verify_get(self.proxy.get_limits, limits.Limits, method_args=[]) def test_server_interface_create(self): self.verify_create(self.proxy.create_server_interface, @@ -565,9 +568,9 @@ class TestCompute(TestComputeProxy): self.proxy.delete_server_interface, method_args=[test_interface], method_kwargs={"server": server_id}, - expected_args=[server_interface.ServerInterface], + expected_args=[ + server_interface.ServerInterface, interface_id], expected_kwargs={"server_id": server_id, - "port_id": interface_id, "ignore_missing": True}) # Case2: ServerInterface ID is provided as value @@ -575,9 +578,9 @@ class TestCompute(TestComputeProxy): self.proxy.delete_server_interface, method_args=[interface_id], method_kwargs={"server": server_id}, - expected_args=[server_interface.ServerInterface], + expected_args=[ + server_interface.ServerInterface, interface_id], expected_kwargs={"server_id": server_id, - "port_id": interface_id, "ignore_missing": True}) def test_server_interface_delete_ignore(self): @@ -585,9 +588,8 @@ class TestCompute(TestComputeProxy): self.verify_delete(self.proxy.delete_server_interface, server_interface.ServerInterface, True, method_kwargs={"server": "test_id"}, - expected_args=[server_interface.ServerInterface], - expected_kwargs={"server_id": "test_id", - "port_id": "resource_or_id"}) + expected_args=[], + expected_kwargs={"server_id": "test_id"}) def test_server_interface_get(self): self.proxy._get_uri_attribute = lambda *args: args[1] @@ -619,18 +621,21 @@ class TestCompute(TestComputeProxy): self.verify_list(self.proxy.server_interfaces, server_interface.ServerInterface, method_args=["test_id"], + expected_args=[], expected_kwargs={"server_id": "test_id"}) def test_server_ips_with_network_label(self): self.verify_list(self.proxy.server_ips, server_ip.ServerIP, method_args=["test_id"], method_kwargs={"network_label": "test_label"}, + expected_args=[], expected_kwargs={"server_id": "test_id", "network_label": "test_label"}) def test_server_ips_without_network_label(self): self.verify_list(self.proxy.server_ips, server_ip.ServerIP, method_args=["test_id"], + expected_args=[], expected_kwargs={"server_id": "test_id", "network_label": None}) @@ -854,12 +859,14 @@ class TestCompute(TestComputeProxy): def test_availability_zones_not_detailed(self): self.verify_list(self.proxy.availability_zones, az.AvailabilityZone, - method_kwargs={"details": False}) + method_kwargs={"details": False}, + expected_kwargs={}) def test_availability_zones_detailed(self): self.verify_list(self.proxy.availability_zones, az.AvailabilityZoneDetail, - method_kwargs={"details": True}) + method_kwargs={"details": True}, + expected_kwargs={}) def test_get_all_server_metadata(self): self._verify2("openstack.compute.v2.server.Server.get_metadata", diff --git a/openstack/tests/unit/database/v1/test_proxy.py b/openstack/tests/unit/database/v1/test_proxy.py index 5fa4776fc..017810f06 100644 --- a/openstack/tests/unit/database/v1/test_proxy.py +++ b/openstack/tests/unit/database/v1/test_proxy.py @@ -24,21 +24,24 @@ class TestDatabaseProxy(test_proxy_base.TestProxyBase): self.proxy = _proxy.Proxy(self.session) def test_database_create_attrs(self): - self.verify_create(self.proxy.create_database, database.Database, + self.verify_create(self.proxy.create_database, + database.Database, method_kwargs={"instance": "id"}, expected_kwargs={"instance_id": "id"}) def test_database_delete(self): self.verify_delete(self.proxy.delete_database, - database.Database, False, - input_path_args={"instance": "test_id"}, - expected_path_args={"instance_id": "test_id"}) + database.Database, + ignore_missing=False, + method_kwargs={"instance": "test_id"}, + expected_kwargs={"instance_id": "test_id"}) def test_database_delete_ignore(self): self.verify_delete(self.proxy.delete_database, - database.Database, True, - input_path_args={"instance": "test_id"}, - expected_path_args={"instance_id": "test_id"}) + database.Database, + ignore_missing=True, + method_kwargs={"instance": "test_id"}, + expected_kwargs={"instance_id": "test_id"}) def test_database_find(self): self._verify2('openstack.proxy.Proxy._find', @@ -51,6 +54,7 @@ class TestDatabaseProxy(test_proxy_base.TestProxyBase): def test_databases(self): self.verify_list(self.proxy.databases, database.Database, method_args=["id"], + expected_args=[], expected_kwargs={"instance_id": "id"}) def test_database_get(self): @@ -95,13 +99,13 @@ class TestDatabaseProxy(test_proxy_base.TestProxyBase): def test_user_delete(self): self.verify_delete(self.proxy.delete_user, user.User, False, - input_path_args={"instance": "id"}, - expected_path_args={"instance_id": "id"}) + method_kwargs={"instance": "id"}, + expected_kwargs={"instance_id": "id"}) def test_user_delete_ignore(self): self.verify_delete(self.proxy.delete_user, user.User, True, - input_path_args={"instance": "id"}, - expected_path_args={"instance_id": "id"}) + method_kwargs={"instance": "id"}, + expected_kwargs={"instance_id": "id"}) def test_user_find(self): self._verify2('openstack.proxy.Proxy._find', @@ -114,6 +118,7 @@ class TestDatabaseProxy(test_proxy_base.TestProxyBase): def test_users(self): self.verify_list(self.proxy.users, user.User, method_args=["test_instance"], + expected_args=[], expected_kwargs={"instance_id": "test_instance"}) def test_user_get(self): diff --git a/openstack/tests/unit/dns/v2/test_proxy.py b/openstack/tests/unit/dns/v2/test_proxy.py index 125035e92..48369b8f3 100644 --- a/openstack/tests/unit/dns/v2/test_proxy.py +++ b/openstack/tests/unit/dns/v2/test_proxy.py @@ -84,7 +84,7 @@ class TestDnsRecordset(TestDnsProxy): def test_recordsets(self): self.verify_list(self.proxy.recordsets, recordset.Recordset, - base_path='/recordsets') + expected_kwargs={'base_path': '/recordsets'}) def test_recordsets_zone(self): self.verify_list(self.proxy.recordsets, recordset.Recordset, @@ -143,7 +143,7 @@ class TestDnsZoneExport(TestDnsProxy): def test_zone_export_get_text(self): self.verify_get(self.proxy.get_zone_export_text, zone_export.ZoneExport, - value=[{'id': 'zone_export_id_value'}], + method_args=[{'id': 'zone_export_id_value'}], expected_kwargs={ 'base_path': '/zones/tasks/export/%(id)s/export' }) @@ -156,6 +156,7 @@ class TestDnsZoneExport(TestDnsProxy): zone_export.ZoneExport, method_args=[{'id': 'zone_id_value'}], method_kwargs={'name': 'id'}, + expected_args=[], expected_kwargs={'name': 'id', 'zone_id': 'zone_id_value', 'prepend_key': False}) @@ -179,6 +180,7 @@ class TestDnsZoneTransferRequest(TestDnsProxy): zone_transfer.ZoneTransferRequest, method_args=[{'id': 'zone_id_value'}], method_kwargs={'name': 'id'}, + expected_args=[], expected_kwargs={'name': 'id', 'zone_id': 'zone_id_value', 'prepend_key': False}) diff --git a/openstack/tests/unit/image/v2/test_proxy.py b/openstack/tests/unit/image/v2/test_proxy.py index bba3333a5..7983a614d 100644 --- a/openstack/tests/unit/image/v2/test_proxy.py +++ b/openstack/tests/unit/image/v2/test_proxy.py @@ -364,7 +364,7 @@ class TestImageProxy(test_proxy_base.TestProxyBase): def test_members(self): self.verify_list(self.proxy.members, member.Member, - method_args=('image_1',), + method_kwargs={'image': 'image_1'}, expected_kwargs={'image_id': 'image_1'}) def test_images_schema_get(self): diff --git a/openstack/tests/unit/instance_ha/v1/test_proxy.py b/openstack/tests/unit/instance_ha/v1/test_proxy.py index 5e68100f5..8e1049adc 100644 --- a/openstack/tests/unit/instance_ha/v1/test_proxy.py +++ b/openstack/tests/unit/instance_ha/v1/test_proxy.py @@ -31,12 +31,13 @@ class TestInstanceHaProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.hosts, host.Host, method_args=[SEGMENT_ID], + expected_args=[], expected_kwargs={"segment_id": SEGMENT_ID}) def test_host_get(self): self.verify_get(self.proxy.get_host, host.Host, - value=[HOST_ID], + method_args=[HOST_ID], method_kwargs={"segment_id": SEGMENT_ID}, expected_kwargs={"segment_id": SEGMENT_ID}) @@ -45,6 +46,7 @@ class TestInstanceHaProxy(test_proxy_base.TestProxyBase): host.Host, method_args=[SEGMENT_ID], method_kwargs={}, + expected_args=[], expected_kwargs={"segment_id": SEGMENT_ID}) def test_host_update(self): diff --git a/openstack/tests/unit/load_balancer/v2/__init__.py b/openstack/tests/unit/load_balancer/v2/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/openstack/tests/unit/load_balancer/test_proxy.py b/openstack/tests/unit/load_balancer/v2/test_proxy.py similarity index 96% rename from openstack/tests/unit/load_balancer/test_proxy.py rename to openstack/tests/unit/load_balancer/v2/test_proxy.py index 54bd479b6..0983845aa 100644 --- a/openstack/tests/unit/load_balancer/test_proxy.py +++ b/openstack/tests/unit/load_balancer/v2/test_proxy.py @@ -56,8 +56,8 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): def test_load_balancer_stats_get(self): self.verify_get(self.proxy.get_load_balancer_statistics, lb.LoadBalancerStats, - value=[self.LB_ID], - expected_args=[lb.LoadBalancerStats], + method_args=[self.LB_ID], + expected_args=[], expected_kwargs={'lb_id': self.LB_ID, 'requires_id': False}) @@ -108,7 +108,7 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): def test_load_balancer_failover(self): self.verify_update(self.proxy.failover_load_balancer, lb.LoadBalancerFailover, - value=[self.LB_ID], + method_args=[self.LB_ID], expected_args=[], expected_kwargs={'lb_id': self.LB_ID}) @@ -123,8 +123,8 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): def test_listener_stats_get(self): self.verify_get(self.proxy.get_listener_statistics, listener.ListenerStats, - value=[self.LISTENER_ID], - expected_args=[listener.ListenerStats], + method_args=[self.LISTENER_ID], + expected_args=[], expected_kwargs={'listener_id': self.LISTENER_ID, 'requires_id': False}) @@ -189,9 +189,11 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): def test_member_delete(self): self.verify_delete(self.proxy.delete_member, member.Member, - True, + ignore_missing=True, method_kwargs={'pool': self.POOL_ID}, - expected_kwargs={'pool_id': self.POOL_ID}) + expected_kwargs={ + 'pool_id': self.POOL_ID, + 'ignore_missing': True}) def test_member_find(self): self._verify2('openstack.proxy.Proxy._find', @@ -277,7 +279,7 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): def test_l7_rule_delete(self): self.verify_delete(self.proxy.delete_l7_rule, l7_rule.L7Rule, - True, + ignore_missing=True, method_kwargs={'l7_policy': self.L7_POLICY_ID}, expected_kwargs={'l7policy_id': self.L7_POLICY_ID}) @@ -324,6 +326,7 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.provider_flavor_capabilities, provider.ProviderFlavorCapabilities, method_args=[self.AMPHORA], + expected_args=[], expected_kwargs={'provider': self.AMPHORA}) def test_flavor_profiles(self): @@ -380,14 +383,14 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): def test_amphora_configure(self): self.verify_update(self.proxy.configure_amphora, amphora.AmphoraConfig, - value=[self.AMPHORA_ID], + method_args=[self.AMPHORA_ID], expected_args=[], expected_kwargs={'amphora_id': self.AMPHORA_ID}) def test_amphora_failover(self): self.verify_update(self.proxy.failover_amphora, amphora.AmphoraFailover, - value=[self.AMPHORA_ID], + method_args=[self.AMPHORA_ID], expected_args=[], expected_kwargs={'amphora_id': self.AMPHORA_ID}) diff --git a/openstack/tests/unit/message/v2/test_proxy.py b/openstack/tests/unit/message/v2/test_proxy.py index b4bddd9fe..c6866de4d 100644 --- a/openstack/tests/unit/message/v2/test_proxy.py +++ b/openstack/tests/unit/message/v2/test_proxy.py @@ -73,7 +73,7 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): def test_messages(self): self.verify_list(self.proxy.messages, message.Message, - method_args=["test_queue"], + method_kwargs={"queue_name": "test_queue"}, expected_kwargs={"queue_name": "test_queue"}) @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -150,25 +150,29 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): def test_subscriptions(self): self.verify_list(self.proxy.subscriptions, subscription.Subscription, - method_args=["test_queue"], + method_kwargs={"queue_name": "test_queue"}, expected_kwargs={"queue_name": "test_queue"}) @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_subscription_delete(self, mock_get_resource): - mock_get_resource.return_value = "resource_or_id" + mock_get_resource.return_value = "test_subscription" self.verify_delete(self.proxy.delete_subscription, - subscription.Subscription, False, - ["test_queue", "resource_or_id"]) + subscription.Subscription, + ignore_missing=False, + method_args=["test_queue", "resource_or_id"], + expected_args=["test_subscription"]) mock_get_resource.assert_called_once_with( subscription.Subscription, "resource_or_id", queue_name="test_queue") @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_subscription_delete_ignore(self, mock_get_resource): - mock_get_resource.return_value = "resource_or_id" + mock_get_resource.return_value = "test_subscription" self.verify_delete(self.proxy.delete_subscription, - subscription.Subscription, True, - ["test_queue", "resource_or_id"]) + subscription.Subscription, + ignore_missing=True, + method_args=["test_queue", "resource_or_id"], + expected_args=["test_subscription"]) mock_get_resource.assert_called_once_with( subscription.Subscription, "resource_or_id", queue_name="test_queue") @@ -202,12 +206,21 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): def test_claim_delete(self): self.verify_delete(self.proxy.delete_claim, - claim.Claim, False, - ["test_queue", "resource_or_id"], - expected_kwargs={"queue_name": "test_queue"}) + claim.Claim, + ignore_missing=False, + method_args=["test_queue", "test_claim"], + expected_args=["test_claim"], + expected_kwargs={ + "queue_name": "test_queue", + "ignore_missing": False}) def test_claim_delete_ignore(self): - self.verify_delete(self.proxy.delete_claim, - claim.Claim, True, - ["test_queue", "resource_or_id"], - expected_kwargs={"queue_name": "test_queue"}) + self.verify_delete( + self.proxy.delete_claim, + claim.Claim, + ignore_missing=True, + method_args=["test_queue", "test_claim"], + expected_args=["test_claim"], + expected_kwargs={ + "queue_name": "test_queue", "ignore_missing": True, + }) diff --git a/openstack/tests/unit/network/v2/test_proxy.py b/openstack/tests/unit/network/v2/test_proxy.py index 9772d995b..097da6148 100644 --- a/openstack/tests/unit/network/v2/test_proxy.py +++ b/openstack/tests/unit/network/v2/test_proxy.py @@ -72,23 +72,37 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): super(TestNetworkProxy, self).setUp() self.proxy = _proxy.Proxy(self.session) - def verify_update(self, test_method, resource_type, value=None, - mock_method="openstack.network.v2._proxy.Proxy._update", - expected_result="result", path_args=None, **kwargs): - super(TestNetworkProxy, self).verify_update( - test_method, resource_type, value=value, mock_method=mock_method, - expected_result=expected_result, path_args=path_args, **kwargs) + def verify_update( + self, test_method, resource_type, base_path=None, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, expected_result="result", + mock_method="openstack.network.v2._proxy.Proxy._update", + ): + super().verify_update( + test_method, + resource_type, + base_path=base_path, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=expected_args, + expected_kwargs=expected_kwargs, + expected_result=expected_result, + mock_method=mock_method) - def verify_delete(self, test_method, resource_type, ignore, - input_path_args=None, expected_path_args=None, - method_kwargs=None, expected_args=None, - expected_kwargs=None, - mock_method="openstack.network.v2._proxy.Proxy._delete"): - super(TestNetworkProxy, self).verify_delete( - test_method, resource_type, ignore, - input_path_args=input_path_args, - expected_path_args=expected_path_args, method_kwargs=method_kwargs, - expected_args=expected_args, expected_kwargs=expected_kwargs, + def verify_delete( + self, test_method, resource_type, ignore_missing=True, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, + mock_method="openstack.network.v2._proxy.Proxy._delete", + ): + super().verify_delete( + test_method, + resource_type, + ignore_missing=ignore_missing, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=expected_args, + expected_kwargs=expected_kwargs, mock_method=mock_method) def test_address_scope_create_attrs(self): @@ -134,8 +148,9 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_update(self.proxy.update_agent, agent.Agent) def test_availability_zones(self): - self.verify_list_no_kwargs(self.proxy.availability_zones, - availability_zone.AvailabilityZone) + self.verify_list( + self.proxy.availability_zones, + availability_zone.AvailabilityZone) def test_dhcp_agent_hosting_networks(self): self.verify_list( @@ -438,14 +453,20 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): expected_kwargs={"pool_id": "test_id"}) def test_pool_member_delete(self): - self.verify_delete(self.proxy.delete_pool_member, - pool_member.PoolMember, False, - {"pool": "test_id"}, {"pool_id": "test_id"}) + self.verify_delete( + self.proxy.delete_pool_member, + pool_member.PoolMember, + ignore_missing=False, + method_kwargs={"pool": "test_id"}, + expected_kwargs={"pool_id": "test_id"}) def test_pool_member_delete_ignore(self): - self.verify_delete(self.proxy.delete_pool_member, - pool_member.PoolMember, True, - {"pool": "test_id"}, {"pool_id": "test_id"}) + self.verify_delete( + self.proxy.delete_pool_member, + pool_member.PoolMember, + ignore_missing=True, + method_kwargs={"pool": "test_id"}, + expected_kwargs={"pool_id": "test_id"}) def test_pool_member_find(self): self._verify2('openstack.proxy.Proxy._find', @@ -463,9 +484,11 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): expected_kwargs={"pool_id": "POOL"}) def test_pool_members(self): - self.verify_list(self.proxy.pool_members, pool_member.PoolMember, - method_args=["test_id"], - expected_kwargs={"pool_id": "test_id"}) + self.verify_list( + self.proxy.pool_members, pool_member.PoolMember, + method_args=["test_id"], + expected_args=[], + expected_kwargs={"pool_id": "test_id"}) def test_pool_member_update(self): self._verify2("openstack.network.v2._proxy.Proxy._update", @@ -551,14 +574,18 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_delete( self.proxy.delete_qos_bandwidth_limit_rule, qos_bandwidth_limit_rule.QoSBandwidthLimitRule, - False, input_path_args=["resource_or_id", QOS_POLICY_ID], + ignore_missing=False, + method_args=["resource_or_id", QOS_POLICY_ID], + expected_args=["resource_or_id"], expected_kwargs={'qos_policy_id': QOS_POLICY_ID}) def test_qos_bandwidth_limit_rule_delete_ignore(self): self.verify_delete( self.proxy.delete_qos_bandwidth_limit_rule, qos_bandwidth_limit_rule.QoSBandwidthLimitRule, - True, input_path_args=["resource_or_id", QOS_POLICY_ID], + ignore_missing=True, + method_args=["resource_or_id", QOS_POLICY_ID], + expected_args=["resource_or_id"], expected_kwargs={'qos_policy_id': QOS_POLICY_ID}) def test_qos_bandwidth_limit_rule_find(self): @@ -609,15 +636,19 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_delete( self.proxy.delete_qos_dscp_marking_rule, qos_dscp_marking_rule.QoSDSCPMarkingRule, - False, input_path_args=["resource_or_id", QOS_POLICY_ID], - expected_path_args={'qos_policy_id': QOS_POLICY_ID},) + ignore_missing=False, + method_args=["resource_or_id", QOS_POLICY_ID], + expected_args=["resource_or_id"], + expected_kwargs={'qos_policy_id': QOS_POLICY_ID}) def test_qos_dscp_marking_rule_delete_ignore(self): self.verify_delete( self.proxy.delete_qos_dscp_marking_rule, qos_dscp_marking_rule.QoSDSCPMarkingRule, - True, input_path_args=["resource_or_id", QOS_POLICY_ID], - expected_path_args={'qos_policy_id': QOS_POLICY_ID}, ) + ignore_missing=True, + method_args=["resource_or_id", QOS_POLICY_ID], + expected_args=["resource_or_id"], + expected_kwargs={'qos_policy_id': QOS_POLICY_ID}, ) def test_qos_dscp_marking_rule_find(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) @@ -666,15 +697,19 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_delete( self.proxy.delete_qos_minimum_bandwidth_rule, qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule, - False, input_path_args=["resource_or_id", QOS_POLICY_ID], - expected_path_args={'qos_policy_id': QOS_POLICY_ID},) + ignore_missing=False, + method_args=["resource_or_id", QOS_POLICY_ID], + expected_args=["resource_or_id"], + expected_kwargs={'qos_policy_id': QOS_POLICY_ID}) def test_qos_minimum_bandwidth_rule_delete_ignore(self): self.verify_delete( self.proxy.delete_qos_minimum_bandwidth_rule, qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule, - True, input_path_args=["resource_or_id", QOS_POLICY_ID], - expected_path_args={'qos_policy_id': QOS_POLICY_ID}, ) + ignore_missing=True, + method_args=["resource_or_id", QOS_POLICY_ID], + expected_args=["resource_or_id"], + expected_kwargs={'qos_policy_id': QOS_POLICY_ID}) def test_qos_minimum_bandwidth_rule_find(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) @@ -1299,9 +1334,8 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_validate_topology(self): self.verify_get(self.proxy.validate_auto_allocated_topology, auto_allocated_topology.ValidateTopology, - value=[mock.sentinel.project_id], - expected_args=[ - auto_allocated_topology.ValidateTopology], + method_args=[mock.sentinel.project_id], + expected_args=[], expected_kwargs={"project": mock.sentinel.project_id, "requires_id": False}) @@ -1331,15 +1365,19 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_delete( self.proxy.delete_floating_ip_port_forwarding, port_forwarding.PortForwarding, - False, input_path_args=[FIP_ID, "resource_or_id"], - expected_path_args={'floatingip_id': FIP_ID},) + ignore_missing=False, + method_args=[FIP_ID, "resource_or_id"], + expected_args=["resource_or_id"], + expected_kwargs={'floatingip_id': FIP_ID}) def test_delete_floating_ip_port_forwarding_ignore(self): self.verify_delete( self.proxy.delete_floating_ip_port_forwarding, port_forwarding.PortForwarding, - True, input_path_args=[FIP_ID, "resource_or_id"], - expected_path_args={'floatingip_id': FIP_ID}, ) + ignore_missing=True, + method_args=[FIP_ID, "resource_or_id"], + expected_args=["resource_or_id"], + expected_kwargs={'floatingip_id': FIP_ID}) def test_find_floating_ip_port_forwarding(self): fip = floating_ip.FloatingIP.new(id=FIP_ID) @@ -1391,16 +1429,20 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_delete( self.proxy.delete_conntrack_helper, l3_conntrack_helper.ConntrackHelper, - False, input_path_args=['resource_or_id', r], - expected_path_args={'router_id': ROUTER_ID},) + ignore_missing=False, + method_args=['resource_or_id', r], + expected_args=['resource_or_id'], + expected_kwargs={'router_id': ROUTER_ID},) def test_delete_l3_conntrack_helper_ignore(self): r = router.Router.new(id=ROUTER_ID) self.verify_delete( self.proxy.delete_conntrack_helper, l3_conntrack_helper.ConntrackHelper, - True, input_path_args=['resource_or_id', r], - expected_path_args={'router_id': ROUTER_ID}, ) + ignore_missing=True, + method_args=['resource_or_id', r], + expected_args=['resource_or_id'], + expected_kwargs={'router_id': ROUTER_ID},) def test_get_l3_conntrack_helper(self): r = router.Router.new(id=ROUTER_ID) @@ -1416,6 +1458,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.conntrack_helpers, l3_conntrack_helper.ConntrackHelper, method_args=[ROUTER_ID], + expected_args=[], expected_kwargs={'router_id': ROUTER_ID}) def test_update_l3_conntrack_helper(self): diff --git a/openstack/tests/unit/object_store/v1/test_proxy.py b/openstack/tests/unit/object_store/v1/test_proxy.py index 0f7b3bbc1..e24c11542 100644 --- a/openstack/tests/unit/object_store/v1/test_proxy.py +++ b/openstack/tests/unit/object_store/v1/test_proxy.py @@ -39,11 +39,13 @@ class TestObjectStoreProxy(test_proxy_base.TestProxyBase): endpoint=self.endpoint, container=self.container) def test_account_metadata_get(self): - self.verify_head(self.proxy.get_account_metadata, account.Account) + self.verify_head( + self.proxy.get_account_metadata, account.Account, + method_args=[]) def test_container_metadata_get(self): self.verify_head(self.proxy.get_container_metadata, - container.Container, value="container") + container.Container, method_args=["container"]) def test_container_delete(self): self.verify_delete(self.proxy.delete_container, @@ -58,6 +60,7 @@ class TestObjectStoreProxy(test_proxy_base.TestProxyBase): self.proxy.create_container, container.Container, method_args=['container_name'], + expected_args=[], expected_kwargs={'name': 'container_name', "x": 1, "y": 2, "z": 3}) def test_object_metadata_get(self): @@ -103,7 +106,7 @@ class TestObjectStoreProxy(test_proxy_base.TestProxyBase): kwargs = dict(container="container") self.verify_get( self.proxy.get_object, obj.Object, - value=["object"], + method_args=["object"], method_kwargs=kwargs, expected_kwargs=kwargs) diff --git a/openstack/tests/unit/orchestration/v1/test_proxy.py b/openstack/tests/unit/orchestration/v1/test_proxy.py index 945d964ce..32239e024 100644 --- a/openstack/tests/unit/orchestration/v1/test_proxy.py +++ b/openstack/tests/unit/orchestration/v1/test_proxy.py @@ -35,9 +35,11 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): self.verify_create(self.proxy.create_stack, stack.Stack) def test_create_stack_preview(self): - method_kwargs = {"preview": True, "x": 1, "y": 2, "z": 3} - self.verify_create(self.proxy.create_stack, stack.Stack, - method_kwargs=method_kwargs) + self.verify_create( + self.proxy.create_stack, + stack.Stack, + method_kwargs={"preview": True, "x": 1, "y": 2, "z": 3}, + expected_kwargs={"x": 1, "y": 2, "z": 3}) def test_find_stack(self): self.verify_find(self.proxy.find_stack, stack.Stack, @@ -223,6 +225,7 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.resources, resource.Resource, method_args=[stk], + expected_args=[], expected_kwargs={'stack_name': stack_name, 'stack_id': stack_id}) @@ -237,6 +240,7 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.resources, resource.Resource, method_args=[stack_id], + expected_args=[], expected_kwargs={'stack_name': stack_name, 'stack_id': stack_id}) diff --git a/openstack/tests/unit/placement/v1/test_proxy.py b/openstack/tests/unit/placement/v1/test_proxy.py index 1b915c0e9..06a2da1b6 100644 --- a/openstack/tests/unit/placement/v1/test_proxy.py +++ b/openstack/tests/unit/placement/v1/test_proxy.py @@ -51,7 +51,7 @@ class TestPlacementProxy(test_proxy_base.TestProxyBase): ) def test_resource_classes(self): - self.verify_list_no_kwargs( + self.verify_list( self.proxy.resource_classes, resource_class.ResourceClass, ) @@ -85,7 +85,7 @@ class TestPlacementProxy(test_proxy_base.TestProxyBase): ) def test_resource_providers(self): - self.verify_list_no_kwargs( + self.verify_list( self.proxy.resource_providers, resource_provider.ResourceProvider, ) diff --git a/openstack/tests/unit/test_proxy_base.py b/openstack/tests/unit/test_proxy_base.py index 66652aa1a..9e904ae18 100644 --- a/openstack/tests/unit/test_proxy_base.py +++ b/openstack/tests/unit/test_proxy_base.py @@ -20,14 +20,6 @@ class TestProxyBase(base.TestCase): super(TestProxyBase, self).setUp() self.session = mock.Mock() - def _add_path_args_for_verify(self, path_args, method_args, - expected_kwargs, value=None): - if path_args is not None: - if value is None: - for key in path_args: - method_args.append(path_args[key]) - expected_kwargs['path_args'] = path_args - def _verify(self, mock_method, test_method, method_args=None, method_kwargs=None, expected_args=None, expected_kwargs=None, @@ -78,80 +70,99 @@ class TestProxyBase(base.TestCase): **method_kwargs)) # Check how the mock was called in detail (called_args, called_kwargs) = mocked.call_args - self.assertEqual(list(called_args), expected_args) - base_path = expected_kwargs.get('base_path', None) + self.assertEqual(expected_args, list(called_args)) # NOTE(gtema): if base_path is not in expected_kwargs or empty # exclude it from the comparison, since some methods might # still invoke method with None value - if not base_path: + base_path = expected_kwargs.get('base_path', None) + if base_path is None: expected_kwargs.pop('base_path', None) called_kwargs.pop('base_path', None) - self.assertDictEqual(called_kwargs, expected_kwargs) + # ditto for paginated + paginated = expected_kwargs.get('paginated', None) + if paginated is None: + expected_kwargs.pop('paginated', None) + called_kwargs.pop('paginated', None) + # and ignore_missing + ignore_missing = expected_kwargs.get('ignore_missing', None) + if ignore_missing is None: + expected_kwargs.pop('ignore_missing', None) + called_kwargs.pop('ignore_missing', None) + self.assertDictEqual(expected_kwargs, called_kwargs) else: self.assertEqual(expected_result, test_method()) mocked.assert_called_with(test_method.__self__) - def verify_create(self, test_method, resource_type, - mock_method="openstack.proxy.Proxy._create", - expected_result="result", **kwargs): - the_kwargs = {"x": 1, "y": 2, "z": 3} - method_kwargs = kwargs.pop("method_kwargs", the_kwargs) - expected_args = kwargs.pop('expected_args', [resource_type]) - # Default the_kwargs should be copied, since we might need to extend it - expected_kwargs = kwargs.pop("expected_kwargs", the_kwargs.copy()) - expected_kwargs["base_path"] = kwargs.pop("base_path", None) + def verify_create( + self, test_method, resource_type, base_path=None, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, expected_result="result", + mock_method="openstack.proxy.Proxy._create", + ): + if method_args is None: + method_args = [] + if method_kwargs is None: + method_kwargs = {"x": 1, "y": 2, "z": 3} + if expected_args is None: + expected_args = method_args.copy() + if expected_kwargs is None: + expected_kwargs = method_kwargs.copy() + expected_kwargs["base_path"] = base_path - self._verify2(mock_method, test_method, - expected_result=expected_result, - method_kwargs=method_kwargs, - expected_args=expected_args, - expected_kwargs=expected_kwargs, - **kwargs) + self._verify2( + mock_method, + test_method, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=[resource_type] + expected_args, + expected_kwargs=expected_kwargs, + expected_result=expected_result, + ) - def verify_delete(self, test_method, resource_type, ignore, - input_path_args=None, expected_path_args=None, - method_kwargs=None, expected_args=None, - expected_kwargs=None, - mock_method="openstack.proxy.Proxy._delete"): - method_args = ["resource_or_id"] + def verify_delete( + self, test_method, resource_type, ignore_missing=True, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, + mock_method="openstack.proxy.Proxy._delete", + ): + method_args = method_args or ['resource_id'] method_kwargs = method_kwargs or {} - method_kwargs["ignore_missing"] = ignore - if isinstance(input_path_args, dict): - for key in input_path_args: - method_kwargs[key] = input_path_args[key] - elif isinstance(input_path_args, list): - method_args = input_path_args - expected_kwargs = expected_kwargs or {} - expected_kwargs["ignore_missing"] = ignore - if expected_path_args: - expected_kwargs.update(expected_path_args) - expected_args = expected_args or [resource_type, "resource_or_id"] - self._verify2(mock_method, test_method, - method_args=method_args, - method_kwargs=method_kwargs, - expected_args=expected_args, - expected_kwargs=expected_kwargs) + method_kwargs["ignore_missing"] = ignore_missing + expected_args = expected_args or method_args.copy() + expected_kwargs = expected_kwargs or method_kwargs.copy() - def verify_get(self, test_method, resource_type, value=None, args=None, - mock_method="openstack.proxy.Proxy._get", - ignore_value=False, **kwargs): - the_value = value - if value is None: - the_value = [] if ignore_value else ["value"] - expected_args = kwargs.pop("expected_args", []) - expected_kwargs = kwargs.pop("expected_kwargs", {}) - method_kwargs = kwargs.pop("method_kwargs", kwargs) - if args: - expected_kwargs["args"] = args - if kwargs: - expected_kwargs["path_args"] = kwargs - if not expected_args: - expected_args = [resource_type] + the_value - self._verify2(mock_method, test_method, - method_args=the_value, - method_kwargs=method_kwargs or {}, - expected_args=expected_args, - expected_kwargs=expected_kwargs) + self._verify2( + mock_method, + test_method, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=[resource_type] + expected_args, + expected_kwargs=expected_kwargs, + ) + + def verify_get( + self, test_method, resource_type, requires_id=False, base_path=None, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, + mock_method="openstack.proxy.Proxy._get", + ): + if method_args is None: + method_args = ['resource_id'] + if method_kwargs is None: + method_kwargs = {} + if expected_args is None: + expected_args = method_args.copy() + if expected_kwargs is None: + expected_kwargs = method_kwargs.copy() + + self._verify2( + mock_method, + test_method, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=[resource_type] + expected_args, + expected_kwargs=expected_kwargs, + ) def verify_get_overrided(self, proxy, resource_type, patch_target): with mock.patch(patch_target, autospec=True) as res: @@ -162,89 +173,106 @@ class TestProxyBase(base.TestCase): base_path=None, error_message=mock.ANY) - def verify_head(self, test_method, resource_type, - mock_method="openstack.proxy.Proxy._head", - value=None, **kwargs): - the_value = [value] if value is not None else [] - expected_kwargs = {"path_args": kwargs} if kwargs else {} - self._verify2(mock_method, test_method, - method_args=the_value, - method_kwargs=kwargs, - expected_args=[resource_type] + the_value, - expected_kwargs=expected_kwargs) + def verify_head( + self, test_method, resource_type, base_path=None, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, + mock_method="openstack.proxy.Proxy._head", + ): + if method_args is None: + method_args = ['resource_id'] + if method_kwargs is None: + method_kwargs = {} + expected_args = expected_args or method_args.copy() + expected_kwargs = expected_kwargs or method_kwargs.copy() - def verify_find(self, test_method, resource_type, value=None, - mock_method="openstack.proxy.Proxy._find", - path_args=None, **kwargs): - method_args = value or ["name_or_id"] - expected_kwargs = kwargs.pop('expected_kwargs', {}) + self._verify2( + mock_method, + test_method, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=[resource_type] + expected_args, + expected_kwargs=expected_kwargs, + ) - self._add_path_args_for_verify(path_args, method_args, expected_kwargs, - value=value) + def verify_find( + self, test_method, resource_type, name_or_id='resource_name', + ignore_missing=True, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, + mock_method="openstack.proxy.Proxy._find", + ): + method_args = [name_or_id] + (method_args or []) + method_kwargs = method_kwargs or {} + method_kwargs["ignore_missing"] = ignore_missing + expected_args = expected_args or method_args.copy() + expected_kwargs = expected_kwargs or method_kwargs.copy() - # TODO(briancurtin): if sub-tests worked in this mess of - # test dependencies, the following would be a lot easier to work with. - expected_kwargs["ignore_missing"] = False - self._verify2(mock_method, test_method, - method_args=method_args + [False], - expected_args=[resource_type, "name_or_id"], - expected_kwargs=expected_kwargs, - expected_result="result", - **kwargs) + self._verify2( + mock_method, + test_method, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=[resource_type] + expected_args, + expected_kwargs=expected_kwargs, + ) - expected_kwargs["ignore_missing"] = True - self._verify2(mock_method, test_method, - method_args=method_args + [True], - expected_args=[resource_type, "name_or_id"], - expected_kwargs=expected_kwargs, - expected_result="result", - **kwargs) + def verify_list( + self, test_method, resource_type, paginated=None, base_path=None, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, + mock_method="openstack.proxy.Proxy._list", + ): + if method_args is None: + method_args = [] + if method_kwargs is None: + method_kwargs = {} + if paginated is not None: + method_kwargs["paginated"] = paginated + if expected_args is None: + expected_args = method_args.copy() + if expected_kwargs is None: + expected_kwargs = method_kwargs.copy() + if base_path is not None: + expected_kwargs["base_path"] = base_path - def verify_list(self, test_method, resource_type, - mock_method="openstack.proxy.Proxy._list", - **kwargs): - expected_kwargs = kwargs.pop("expected_kwargs", {}) - if 'paginated' in kwargs: - expected_kwargs.update({"paginated": kwargs.pop('paginated')}) - method_kwargs = kwargs.pop("method_kwargs", {}) - expected_kwargs["base_path"] = kwargs.pop("base_path", None) - self._verify2(mock_method, test_method, - method_kwargs=method_kwargs, - expected_args=[resource_type], - expected_kwargs=expected_kwargs, - expected_result=["result"], - **kwargs) + self._verify2( + mock_method, + test_method, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=[resource_type] + expected_args, + expected_kwargs=expected_kwargs, + ) - def verify_list_no_kwargs(self, test_method, resource_type, - mock_method="openstack.proxy.Proxy._list"): - self._verify2(mock_method, test_method, - method_kwargs={}, - expected_args=[resource_type], - expected_kwargs={}, - expected_result=["result"]) + def verify_update( + self, test_method, resource_type, base_path=None, *, + method_args=None, method_kwargs=None, + expected_args=None, expected_kwargs=None, expected_result="result", + mock_method="openstack.proxy.Proxy._update", + ): + if method_args is None: + method_args = ['resource_id'] + if method_kwargs is None: + method_kwargs = {"x": 1, "y": 2, "z": 3} + method_kwargs["base_path"] = base_path + if expected_args is None: + expected_args = method_args.copy() + if expected_kwargs is None: + expected_kwargs = method_kwargs.copy() - def verify_update(self, test_method, resource_type, value=None, - mock_method="openstack.proxy.Proxy._update", - expected_result="result", path_args=None, **kwargs): - method_args = value or ["resource_or_id"] - method_kwargs = kwargs.pop("method_kwargs", {}) - method_kwargs.update({"x": 1, "y": 2, "z": 3}) - expected_args = kwargs.pop("expected_args", ["resource_or_id"]) - expected_kwargs = kwargs.pop("expected_kwargs", method_kwargs.copy()) - expected_kwargs["base_path"] = kwargs.pop("base_path", None) - - self._add_path_args_for_verify(path_args, method_args, expected_kwargs, - value=value) - - self._verify2(mock_method, test_method, - expected_result=expected_result, - method_args=method_args, - method_kwargs=method_kwargs, - expected_args=[resource_type] + expected_args, - expected_kwargs=expected_kwargs, - **kwargs) + self._verify2( + mock_method, + test_method, + method_args=method_args, + method_kwargs=method_kwargs, + expected_args=[resource_type] + expected_args, + expected_kwargs=expected_kwargs, + ) def verify_wait_for_status( - self, test_method, - mock_method="openstack.resource.wait_for_status", **kwargs): + self, test_method, + mock_method="openstack.resource.wait_for_status", + **kwargs, + ): self._verify(mock_method, test_method, **kwargs) diff --git a/openstack/tests/unit/workflow/v2/__init__.py b/openstack/tests/unit/workflow/v2/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/openstack/tests/unit/workflow/test_proxy.py b/openstack/tests/unit/workflow/v2/test_proxy.py similarity index 100% rename from openstack/tests/unit/workflow/test_proxy.py rename to openstack/tests/unit/workflow/v2/test_proxy.py From 6f98539497dd7b0507382fcca3ec584f3a2174b0 Mon Sep 17 00:00:00 2001 From: Stephen Finucane Date: Mon, 26 Apr 2021 12:01:41 +0100 Subject: [PATCH 11/16] tests: Remove final use of 'TestProxyBase._verify' Everything now uses '_verify2'...at least until we rename that in the next patch. Change-Id: Ia572acde839370fd2aca34f0413d2e5937a912d0 Signed-off-by: Stephen Finucane --- .../tests/unit/block_storage/v2/test_proxy.py | 9 +- .../tests/unit/block_storage/v3/test_proxy.py | 27 +- .../tests/unit/clustering/v1/test_proxy.py | 92 ++-- openstack/tests/unit/compute/v2/test_proxy.py | 403 ++++++++++-------- openstack/tests/unit/image/v2/test_proxy.py | 63 +-- openstack/tests/unit/message/v2/test_proxy.py | 29 +- openstack/tests/unit/network/v2/test_proxy.py | 107 +++-- openstack/tests/unit/test_proxy_base.py | 27 +- 8 files changed, 437 insertions(+), 320 deletions(-) diff --git a/openstack/tests/unit/block_storage/v2/test_proxy.py b/openstack/tests/unit/block_storage/v2/test_proxy.py index 8f89a6d27..a77e08aab 100644 --- a/openstack/tests/unit/block_storage/v2/test_proxy.py +++ b/openstack/tests/unit/block_storage/v2/test_proxy.py @@ -88,10 +88,11 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_volume, volume.Volume, True) def test_volume_extend(self): - self._verify("openstack.block_storage.v2.volume.Volume.extend", - self.proxy.extend_volume, - method_args=["value", "new-size"], - expected_args=["new-size"]) + self._verify2( + "openstack.block_storage.v2.volume.Volume.extend", + self.proxy.extend_volume, + method_args=["value", "new-size"], + expected_args=[self.proxy, "new-size"]) def test_backend_pools(self): self.verify_list(self.proxy.backend_pools, stats.Pools) diff --git a/openstack/tests/unit/block_storage/v3/test_proxy.py b/openstack/tests/unit/block_storage/v3/test_proxy.py index c6a949f4d..c73f6e22a 100644 --- a/openstack/tests/unit/block_storage/v3/test_proxy.py +++ b/openstack/tests/unit/block_storage/v3/test_proxy.py @@ -155,22 +155,25 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_volume, volume.Volume, True) def test_volume_extend(self): - self._verify("openstack.block_storage.v3.volume.Volume.extend", - self.proxy.extend_volume, - method_args=["value", "new-size"], - expected_args=["new-size"]) + self._verify2( + "openstack.block_storage.v3.volume.Volume.extend", + self.proxy.extend_volume, + method_args=["value", "new-size"], + expected_args=[self.proxy, "new-size"]) def test_volume_set_readonly_no_argument(self): - self._verify("openstack.block_storage.v3.volume.Volume.set_readonly", - self.proxy.set_volume_readonly, - method_args=["value"], - expected_args=[True]) + self._verify2( + "openstack.block_storage.v3.volume.Volume.set_readonly", + self.proxy.set_volume_readonly, + method_args=["value"], + expected_args=[self.proxy, True]) def test_volume_set_readonly_false(self): - self._verify("openstack.block_storage.v3.volume.Volume.set_readonly", - self.proxy.set_volume_readonly, - method_args=["value", False], - expected_args=[False]) + self._verify2( + "openstack.block_storage.v3.volume.Volume.set_readonly", + self.proxy.set_volume_readonly, + method_args=["value", False], + expected_args=[self.proxy, False]) def test_backend_pools(self): self.verify_list(self.proxy.backend_pools, stats.Pools) diff --git a/openstack/tests/unit/clustering/v1/test_proxy.py b/openstack/tests/unit/clustering/v1/test_proxy.py index 360b6447a..f06be57c5 100644 --- a/openstack/tests/unit/clustering/v1/test_proxy.py +++ b/openstack/tests/unit/clustering/v1/test_proxy.py @@ -91,9 +91,11 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_cluster, cluster.Cluster, True) def test_cluster_force_delete(self): - self._verify("openstack.clustering.v1.cluster.Cluster.force_delete", - self.proxy.delete_cluster, - method_args=["value", False, True]) + self._verify2( + "openstack.clustering.v1.cluster.Cluster.force_delete", + self.proxy.delete_cluster, + method_args=["value", False, True], + expected_args=[self.proxy]) def test_cluster_find(self): self.verify_find(self.proxy.find_cluster, cluster.Cluster) @@ -117,21 +119,25 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_resize_cluster(self, mock_find): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') mock_find.return_value = mock_cluster - self._verify("openstack.clustering.v1.cluster.Cluster.resize", - self.proxy.resize_cluster, - method_args=["FAKE_CLUSTER"], - method_kwargs={'k1': 'v1', 'k2': 'v2'}, - expected_kwargs={'k1': 'v1', 'k2': 'v2'}) + self._verify2( + "openstack.clustering.v1.cluster.Cluster.resize", + self.proxy.resize_cluster, + method_args=["FAKE_CLUSTER"], + method_kwargs={'k1': 'v1', 'k2': 'v2'}, + expected_args=[self.proxy], + expected_kwargs={'k1': 'v1', 'k2': 'v2'}) mock_find.assert_called_once_with(cluster.Cluster, "FAKE_CLUSTER", ignore_missing=False) def test_resize_cluster_with_obj(self): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') - self._verify("openstack.clustering.v1.cluster.Cluster.resize", - self.proxy.resize_cluster, - method_args=[mock_cluster], - method_kwargs={'k1': 'v1', 'k2': 'v2'}, - expected_kwargs={'k1': 'v1', 'k2': 'v2'}) + self._verify2( + "openstack.clustering.v1.cluster.Cluster.resize", + self.proxy.resize_cluster, + method_args=[mock_cluster], + method_kwargs={'k1': 'v1', 'k2': 'v2'}, + expected_args=[self.proxy], + expected_kwargs={'k1': 'v1', 'k2': 'v2'}) def test_collect_cluster_attrs(self): self.verify_list(self.proxy.collect_cluster_attrs, @@ -145,18 +151,22 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_cluster_check(self, mock_get): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') mock_get.return_value = mock_cluster - self._verify("openstack.clustering.v1.cluster.Cluster.check", - self.proxy.check_cluster, - method_args=["FAKE_CLUSTER"]) + self._verify2( + "openstack.clustering.v1.cluster.Cluster.check", + self.proxy.check_cluster, + method_args=["FAKE_CLUSTER"], + expected_args=[self.proxy]) mock_get.assert_called_once_with(cluster.Cluster, "FAKE_CLUSTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_cluster_recover(self, mock_get): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') mock_get.return_value = mock_cluster - self._verify("openstack.clustering.v1.cluster.Cluster.recover", - self.proxy.recover_cluster, - method_args=["FAKE_CLUSTER"]) + self._verify2( + "openstack.clustering.v1.cluster.Cluster.recover", + self.proxy.recover_cluster, + method_args=["FAKE_CLUSTER"], + expected_args=[self.proxy]) mock_get.assert_called_once_with(cluster.Cluster, "FAKE_CLUSTER") def test_node_create(self): @@ -169,9 +179,11 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_node, node.Node, True) def test_node_force_delete(self): - self._verify("openstack.clustering.v1.node.Node.force_delete", - self.proxy.delete_node, - method_args=["value", False, True]) + self._verify2( + "openstack.clustering.v1.node.Node.force_delete", + self.proxy.delete_node, + method_args=["value", False, True], + expected_args=[self.proxy]) def test_node_find(self): self.verify_find(self.proxy.find_node, node.Node) @@ -200,28 +212,34 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_node_check(self, mock_get): mock_node = node.Node.new(id='FAKE_NODE') mock_get.return_value = mock_node - self._verify("openstack.clustering.v1.node.Node.check", - self.proxy.check_node, - method_args=["FAKE_NODE"]) + self._verify2( + "openstack.clustering.v1.node.Node.check", + self.proxy.check_node, + method_args=["FAKE_NODE"], + expected_args=[self.proxy]) mock_get.assert_called_once_with(node.Node, "FAKE_NODE") @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_node_recover(self, mock_get): mock_node = node.Node.new(id='FAKE_NODE') mock_get.return_value = mock_node - self._verify("openstack.clustering.v1.node.Node.recover", - self.proxy.recover_node, - method_args=["FAKE_NODE"]) + self._verify2( + "openstack.clustering.v1.node.Node.recover", + self.proxy.recover_node, + method_args=["FAKE_NODE"], + expected_args=[self.proxy]) mock_get.assert_called_once_with(node.Node, "FAKE_NODE") @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_node_adopt(self, mock_get): mock_node = node.Node.new() mock_get.return_value = mock_node - self._verify("openstack.clustering.v1.node.Node.adopt", - self.proxy.adopt_node, - method_kwargs={"preview": False, "foo": "bar"}, - expected_kwargs={"preview": False, "foo": "bar"}) + self._verify2( + "openstack.clustering.v1.node.Node.adopt", + self.proxy.adopt_node, + method_kwargs={"preview": False, "foo": "bar"}, + expected_args=[self.proxy], + expected_kwargs={"preview": False, "foo": "bar"}) mock_get.assert_called_once_with(node.Node, None) @@ -229,10 +247,12 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_node_adopt_preview(self, mock_get): mock_node = node.Node.new() mock_get.return_value = mock_node - self._verify("openstack.clustering.v1.node.Node.adopt", - self.proxy.adopt_node, - method_kwargs={"preview": True, "foo": "bar"}, - expected_kwargs={"preview": True, "foo": "bar"}) + self._verify2( + "openstack.clustering.v1.node.Node.adopt", + self.proxy.adopt_node, + method_kwargs={"preview": True, "foo": "bar"}, + expected_args=[self.proxy], + expected_kwargs={"preview": True, "foo": "bar"}) mock_get.assert_called_once_with(node.Node, None) diff --git a/openstack/tests/unit/compute/v2/test_proxy.py b/openstack/tests/unit/compute/v2/test_proxy.py index b7d2c1455..2dcb4adbe 100644 --- a/openstack/tests/unit/compute/v2/test_proxy.py +++ b/openstack/tests/unit/compute/v2/test_proxy.py @@ -193,58 +193,61 @@ class TestFlavor(TestComputeProxy): ) def test_flavor_get_access(self): - self._verify("openstack.compute.v2.flavor.Flavor.get_access", - self.proxy.get_flavor_access, - method_args=["value"], - expected_args=[]) + self._verify2( + "openstack.compute.v2.flavor.Flavor.get_access", + self.proxy.get_flavor_access, + method_args=["value"], + expected_args=[self.proxy]) def test_flavor_add_tenant_access(self): - self._verify("openstack.compute.v2.flavor.Flavor.add_tenant_access", - self.proxy.flavor_add_tenant_access, - method_args=["value", "fake-tenant"], - expected_args=["fake-tenant"]) + self._verify2( + "openstack.compute.v2.flavor.Flavor.add_tenant_access", + self.proxy.flavor_add_tenant_access, + method_args=["value", "fake-tenant"], + expected_args=[self.proxy, "fake-tenant"]) def test_flavor_remove_tenant_access(self): - self._verify("openstack.compute.v2.flavor.Flavor.remove_tenant_access", - self.proxy.flavor_remove_tenant_access, - method_args=["value", "fake-tenant"], - expected_args=["fake-tenant"]) + self._verify2( + "openstack.compute.v2.flavor.Flavor.remove_tenant_access", + self.proxy.flavor_remove_tenant_access, + method_args=["value", "fake-tenant"], + expected_args=[self.proxy, "fake-tenant"]) def test_flavor_fetch_extra_specs(self): - self._verify("openstack.compute.v2.flavor.Flavor.fetch_extra_specs", - self.proxy.fetch_flavor_extra_specs, - method_args=["value"], - expected_args=[]) + self._verify2( + "openstack.compute.v2.flavor.Flavor.fetch_extra_specs", + self.proxy.fetch_flavor_extra_specs, + method_args=["value"], + expected_args=[self.proxy]) def test_create_flavor_extra_specs(self): - specs = { - 'a': 'b' - } - self._verify("openstack.compute.v2.flavor.Flavor.create_extra_specs", - self.proxy.create_flavor_extra_specs, - method_args=["value", specs], - expected_kwargs={"specs": specs}) + self._verify2( + "openstack.compute.v2.flavor.Flavor.create_extra_specs", + self.proxy.create_flavor_extra_specs, + method_args=["value", {'a': 'b'}], + expected_args=[self.proxy], + expected_kwargs={"specs": {'a': 'b'}}) def test_get_flavor_extra_specs_prop(self): - self._verify( + self._verify2( "openstack.compute.v2.flavor.Flavor.get_extra_specs_property", self.proxy.get_flavor_extra_specs_property, method_args=["value", "prop"], - expected_args=["prop"]) + expected_args=[self.proxy, "prop"]) def test_update_flavor_extra_specs_prop(self): - self._verify( + self._verify2( "openstack.compute.v2.flavor.Flavor.update_extra_specs_property", self.proxy.update_flavor_extra_specs_property, method_args=["value", "prop", "val"], - expected_args=["prop", "val"]) + expected_args=[self.proxy, "prop", "val"]) def test_delete_flavor_extra_specs_prop(self): - self._verify( + self._verify2( "openstack.compute.v2.flavor.Flavor.delete_extra_specs_property", self.proxy.delete_flavor_extra_specs_property, method_args=["value", "prop"], - expected_args=["prop"]) + expected_args=[self.proxy, "prop"]) class TestKeyPair(TestComputeProxy): @@ -321,36 +324,39 @@ class TestAggregate(TestComputeProxy): self.verify_update(self.proxy.update_aggregate, aggregate.Aggregate) def test_aggregate_add_host(self): - self._verify("openstack.compute.v2.aggregate.Aggregate.add_host", - self.proxy.add_host_to_aggregate, - method_args=["value", "host"], - expected_args=["host"]) + self._verify2( + "openstack.compute.v2.aggregate.Aggregate.add_host", + self.proxy.add_host_to_aggregate, + method_args=["value", "host"], + expected_args=[self.proxy, "host"]) def test_aggregate_remove_host(self): - self._verify("openstack.compute.v2.aggregate.Aggregate.remove_host", - self.proxy.remove_host_from_aggregate, - method_args=["value", "host"], - expected_args=["host"]) + self._verify2( + "openstack.compute.v2.aggregate.Aggregate.remove_host", + self.proxy.remove_host_from_aggregate, + method_args=["value", "host"], + expected_args=[self.proxy, "host"]) def test_aggregate_set_metadata(self): - self._verify("openstack.compute.v2.aggregate.Aggregate.set_metadata", - self.proxy.set_aggregate_metadata, - method_args=["value", {'a': 'b'}], - expected_args=[{'a': 'b'}]) + self._verify2( + "openstack.compute.v2.aggregate.Aggregate.set_metadata", + self.proxy.set_aggregate_metadata, + method_args=["value", {'a': 'b'}], + expected_args=[self.proxy, {'a': 'b'}]) def test_aggregate_precache_image(self): - self._verify( + self._verify2( "openstack.compute.v2.aggregate.Aggregate.precache_images", self.proxy.aggregate_precache_images, method_args=["value", '1'], - expected_args=[[{'id': '1'}]]) + expected_args=[self.proxy, [{'id': '1'}]]) def test_aggregate_precache_images(self): - self._verify( + self._verify2( "openstack.compute.v2.aggregate.Aggregate.precache_images", self.proxy.aggregate_precache_images, method_args=["value", ['1', '2']], - expected_args=[[{'id': '1'}, {'id': '2'}]]) + expected_args=[self.proxy, [{'id': '1'}, {'id': '2'}]]) class TestService(TestComputeProxy): @@ -510,11 +516,11 @@ class TestHypervisor(TestComputeProxy): hypervisor.Hypervisor) def test_get_hypervisor_uptime(self): - self._verify( + self._verify2( "openstack.compute.v2.hypervisor.Hypervisor.get_uptime", self.proxy.get_hypervisor_uptime, method_args=["value"], - expected_args=[]) + expected_args=[self.proxy]) class TestCompute(TestComputeProxy): @@ -649,9 +655,11 @@ class TestCompute(TestComputeProxy): self.verify_delete(self.proxy.delete_server, server.Server, True) def test_server_force_delete(self): - self._verify("openstack.compute.v2.server.Server.force_delete", - self.proxy.delete_server, - method_args=["value", False, True]) + self._verify2( + "openstack.compute.v2.server.Server.force_delete", + self.proxy.delete_server, + method_args=["value", False, True], + expected_args=[self.proxy]) def test_server_find(self): self.verify_find(self.proxy.find_server, server.Server) @@ -680,23 +688,28 @@ class TestCompute(TestComputeProxy): self.verify_wait_for_status( self.proxy.wait_for_server, method_args=[value], - expected_args=[value, 'ACTIVE', ['ERROR'], 2, 120]) + expected_args=[self.proxy, value, 'ACTIVE', ['ERROR'], 2, 120]) def test_server_resize(self): - self._verify("openstack.compute.v2.server.Server.resize", - self.proxy.resize_server, - method_args=["value", "test-flavor"], - expected_args=["test-flavor"]) + self._verify2( + "openstack.compute.v2.server.Server.resize", + self.proxy.resize_server, + method_args=["value", "test-flavor"], + expected_args=[self.proxy, "test-flavor"]) def test_server_confirm_resize(self): - self._verify("openstack.compute.v2.server.Server.confirm_resize", - self.proxy.confirm_server_resize, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.confirm_resize", + self.proxy.confirm_server_resize, + method_args=["value"], + expected_args=[self.proxy]) def test_server_revert_resize(self): - self._verify("openstack.compute.v2.server.Server.revert_resize", - self.proxy.revert_server_resize, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.revert_resize", + self.proxy.revert_server_resize, + method_args=["value"], + expected_args=[self.proxy]) def test_server_rebuild(self): id = 'test_image_id' @@ -705,156 +718,191 @@ class TestCompute(TestComputeProxy): # Case1: image object is provided # NOTE: Inside of Server.rebuild is where image_obj gets converted # to an ID instead of object. - self._verify('openstack.compute.v2.server.Server.rebuild', - self.proxy.rebuild_server, - method_args=["value", "test_server", "test_pass"], - method_kwargs={"metadata": {"k1": "v1"}, - "image": image_obj}, - expected_args=["test_server", "test_pass"], - expected_kwargs={"metadata": {"k1": "v1"}, - "image": image_obj}) + self._verify2( + 'openstack.compute.v2.server.Server.rebuild', + self.proxy.rebuild_server, + method_args=["value", "test_server", "test_pass"], + method_kwargs={"metadata": {"k1": "v1"}, "image": image_obj}, + expected_args=[self.proxy, "test_server", "test_pass"], + expected_kwargs={"metadata": {"k1": "v1"}, "image": image_obj}) # Case2: image name or id is provided - self._verify('openstack.compute.v2.server.Server.rebuild', - self.proxy.rebuild_server, - method_args=["value", "test_server", "test_pass"], - method_kwargs={"metadata": {"k1": "v1"}, - "image": id}, - expected_args=["test_server", "test_pass"], - expected_kwargs={"metadata": {"k1": "v1"}, - "image": id}) + self._verify2( + 'openstack.compute.v2.server.Server.rebuild', + self.proxy.rebuild_server, + method_args=["value", "test_server", "test_pass"], + method_kwargs={"metadata": {"k1": "v1"}, "image": id}, + expected_args=[self.proxy, "test_server", "test_pass"], + expected_kwargs={"metadata": {"k1": "v1"}, "image": id}) def test_add_fixed_ip_to_server(self): - self._verify("openstack.compute.v2.server.Server.add_fixed_ip", - self.proxy.add_fixed_ip_to_server, - method_args=["value", "network-id"], - expected_args=["network-id"]) + self._verify2( + "openstack.compute.v2.server.Server.add_fixed_ip", + self.proxy.add_fixed_ip_to_server, + method_args=["value", "network-id"], + expected_args=[self.proxy, "network-id"]) def test_fixed_ip_from_server(self): - self._verify("openstack.compute.v2.server.Server.remove_fixed_ip", - self.proxy.remove_fixed_ip_from_server, - method_args=["value", "address"], - expected_args=["address"]) + self._verify2( + "openstack.compute.v2.server.Server.remove_fixed_ip", + self.proxy.remove_fixed_ip_from_server, + method_args=["value", "address"], + expected_args=[self.proxy, "address"]) def test_floating_ip_to_server(self): - self._verify("openstack.compute.v2.server.Server.add_floating_ip", - self.proxy.add_floating_ip_to_server, - method_args=["value", "floating-ip"], - expected_args=["floating-ip"], - expected_kwargs={'fixed_address': None}) + self._verify2( + "openstack.compute.v2.server.Server.add_floating_ip", + self.proxy.add_floating_ip_to_server, + method_args=["value", "floating-ip"], + expected_args=[self.proxy, "floating-ip"], + expected_kwargs={'fixed_address': None}) def test_add_floating_ip_to_server_with_fixed_addr(self): - self._verify("openstack.compute.v2.server.Server.add_floating_ip", - self.proxy.add_floating_ip_to_server, - method_args=["value", "floating-ip", 'fixed-addr'], - expected_args=["floating-ip"], - expected_kwargs={'fixed_address': 'fixed-addr'}) + self._verify2( + "openstack.compute.v2.server.Server.add_floating_ip", + self.proxy.add_floating_ip_to_server, + method_args=["value", "floating-ip", 'fixed-addr'], + expected_args=[self.proxy, "floating-ip"], + expected_kwargs={'fixed_address': 'fixed-addr'}) def test_remove_floating_ip_from_server(self): - self._verify("openstack.compute.v2.server.Server.remove_floating_ip", - self.proxy.remove_floating_ip_from_server, - method_args=["value", "address"], - expected_args=["address"]) + self._verify2( + "openstack.compute.v2.server.Server.remove_floating_ip", + self.proxy.remove_floating_ip_from_server, + method_args=["value", "address"], + expected_args=[self.proxy, "address"]) def test_server_backup(self): - self._verify("openstack.compute.v2.server.Server.backup", - self.proxy.backup_server, - method_args=["value", "name", "daily", 1], - expected_args=["name", "daily", 1]) + self._verify2( + "openstack.compute.v2.server.Server.backup", + self.proxy.backup_server, + method_args=["value", "name", "daily", 1], + expected_args=[self.proxy, "name", "daily", 1]) def test_server_pause(self): - self._verify("openstack.compute.v2.server.Server.pause", - self.proxy.pause_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.pause", + self.proxy.pause_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_unpause(self): - self._verify("openstack.compute.v2.server.Server.unpause", - self.proxy.unpause_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.unpause", + self.proxy.unpause_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_suspend(self): - self._verify("openstack.compute.v2.server.Server.suspend", - self.proxy.suspend_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.suspend", + self.proxy.suspend_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_resume(self): - self._verify("openstack.compute.v2.server.Server.resume", - self.proxy.resume_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.resume", + self.proxy.resume_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_lock(self): - self._verify("openstack.compute.v2.server.Server.lock", - self.proxy.lock_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.lock", + self.proxy.lock_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_unlock(self): - self._verify("openstack.compute.v2.server.Server.unlock", - self.proxy.unlock_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.unlock", + self.proxy.unlock_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_rescue(self): - self._verify("openstack.compute.v2.server.Server.rescue", - self.proxy.rescue_server, - method_args=["value"], - expected_kwargs={"admin_pass": None, "image_ref": None}) + self._verify2( + "openstack.compute.v2.server.Server.rescue", + self.proxy.rescue_server, + method_args=["value"], + expected_args=[self.proxy], + expected_kwargs={"admin_pass": None, "image_ref": None}) def test_server_rescue_with_options(self): - self._verify("openstack.compute.v2.server.Server.rescue", - self.proxy.rescue_server, - method_args=["value", 'PASS', 'IMG'], - expected_kwargs={"admin_pass": 'PASS', - "image_ref": 'IMG'}) + self._verify2( + "openstack.compute.v2.server.Server.rescue", + self.proxy.rescue_server, + method_args=["value", 'PASS', 'IMG'], + expected_args=[self.proxy], + expected_kwargs={"admin_pass": 'PASS', "image_ref": 'IMG'}) def test_server_unrescue(self): - self._verify("openstack.compute.v2.server.Server.unrescue", - self.proxy.unrescue_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.unrescue", + self.proxy.unrescue_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_evacuate(self): - self._verify("openstack.compute.v2.server.Server.evacuate", - self.proxy.evacuate_server, - method_args=["value"], - expected_kwargs={"host": None, "admin_pass": None, - "force": None}) + self._verify2( + "openstack.compute.v2.server.Server.evacuate", + self.proxy.evacuate_server, + method_args=["value"], + expected_args=[self.proxy], + expected_kwargs={"host": None, "admin_pass": None, "force": None}) def test_server_evacuate_with_options(self): - self._verify("openstack.compute.v2.server.Server.evacuate", - self.proxy.evacuate_server, - method_args=["value", 'HOST2', 'NEW_PASS', True], - expected_kwargs={"host": "HOST2", - "admin_pass": 'NEW_PASS', - "force": True}) + self._verify2( + "openstack.compute.v2.server.Server.evacuate", + self.proxy.evacuate_server, + method_args=["value", 'HOST2', 'NEW_PASS', True], + expected_args=[self.proxy], + expected_kwargs={ + "host": "HOST2", "admin_pass": 'NEW_PASS', "force": True}) def test_server_start(self): - self._verify("openstack.compute.v2.server.Server.start", - self.proxy.start_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.start", + self.proxy.start_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_stop(self): - self._verify("openstack.compute.v2.server.Server.stop", - self.proxy.stop_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.stop", + self.proxy.stop_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_shelve(self): - self._verify("openstack.compute.v2.server.Server.shelve", - self.proxy.shelve_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.shelve", + self.proxy.shelve_server, + method_args=["value"], + expected_args=[self.proxy]) def test_server_unshelve(self): - self._verify("openstack.compute.v2.server.Server.unshelve", - self.proxy.unshelve_server, - method_args=["value"]) + self._verify2( + "openstack.compute.v2.server.Server.unshelve", + self.proxy.unshelve_server, + method_args=["value"], + expected_args=[self.proxy]) def test_get_server_output(self): - self._verify("openstack.compute.v2.server.Server.get_console_output", - self.proxy.get_server_console_output, - method_args=["value"], - expected_kwargs={"length": None}) + self._verify2( + "openstack.compute.v2.server.Server.get_console_output", + self.proxy.get_server_console_output, + method_args=["value"], + expected_args=[self.proxy], + expected_kwargs={"length": None}) - self._verify("openstack.compute.v2.server.Server.get_console_output", - self.proxy.get_server_console_output, - method_args=["value", 1], - expected_kwargs={"length": 1}) + self._verify2( + "openstack.compute.v2.server.Server.get_console_output", + self.proxy.get_server_console_output, + method_args=["value", 1], + expected_args=[self.proxy], + expected_kwargs={"length": 1}) def test_availability_zones_not_detailed(self): self.verify_list(self.proxy.availability_zones, @@ -947,32 +995,33 @@ class TestCompute(TestComputeProxy): self.verify_list(self.proxy.server_groups, server_group.ServerGroup) def test_live_migrate_server(self): - self._verify('openstack.compute.v2.server.Server.live_migrate', - self.proxy.live_migrate_server, - method_args=["value", "host1", False], - expected_args=["host1"], - expected_kwargs={'force': False, 'block_migration': None}) + self._verify2( + 'openstack.compute.v2.server.Server.live_migrate', + self.proxy.live_migrate_server, + method_args=["value", "host1", False], + expected_args=[self.proxy, "host1"], + expected_kwargs={'force': False, 'block_migration': None}) def test_fetch_security_groups(self): - self._verify( + self._verify2( 'openstack.compute.v2.server.Server.fetch_security_groups', self.proxy.fetch_server_security_groups, method_args=["value"], - expected_args=[]) + expected_args=[self.proxy]) def test_add_security_groups(self): - self._verify( + self._verify2( 'openstack.compute.v2.server.Server.add_security_group', self.proxy.add_security_group_to_server, method_args=["value", {'id': 'id', 'name': 'sg'}], - expected_args=['sg']) + expected_args=[self.proxy, 'sg']) def test_remove_security_groups(self): - self._verify( + self._verify2( 'openstack.compute.v2.server.Server.remove_security_group', self.proxy.remove_security_group_from_server, method_args=["value", {'id': 'id', 'name': 'sg'}], - expected_args=['sg']) + expected_args=[self.proxy, 'sg']) def test_create_server_remote_console(self): self.verify_create( @@ -982,11 +1031,11 @@ class TestCompute(TestComputeProxy): expected_kwargs={"server_id": "test_id", "type": "fake"}) def test_get_console_url(self): - self._verify( + self._verify2( 'openstack.compute.v2.server.Server.get_console_url', self.proxy.get_server_console_url, method_args=["value", "console_type"], - expected_args=["console_type"]) + expected_args=[self.proxy, "console_type"]) @mock.patch('openstack.utils.supports_microversion', autospec=True) @mock.patch('openstack.compute.v2._proxy.Proxy._create', autospec=True) diff --git a/openstack/tests/unit/image/v2/test_proxy.py b/openstack/tests/unit/image/v2/test_proxy.py index 7983a614d..715d4b2a1 100644 --- a/openstack/tests/unit/image/v2/test_proxy.py +++ b/openstack/tests/unit/image/v2/test_proxy.py @@ -54,10 +54,11 @@ class TestImageProxy(test_proxy_base.TestProxyBase): def test_image_import(self): original_image = image.Image(**EXAMPLE) - self._verify( + self._verify2( "openstack.image.v2.image.Image.import_image", self.proxy.import_image, method_args=[original_image, "method", "uri"], + expected_args=[self.proxy], expected_kwargs={ "method": "method", "store": None, @@ -218,17 +219,21 @@ class TestImageProxy(test_proxy_base.TestProxyBase): def test_image_download(self): original_image = image.Image(**EXAMPLE) - self._verify('openstack.image.v2.image.Image.download', - self.proxy.download_image, - method_args=[original_image], - method_kwargs={ - 'output': 'some_output', - 'chunk_size': 1, - 'stream': True - }, - expected_kwargs={'output': 'some_output', - 'chunk_size': 1, - 'stream': True}) + self._verify2( + 'openstack.image.v2.image.Image.download', + self.proxy.download_image, + method_args=[original_image], + method_kwargs={ + 'output': 'some_output', + 'chunk_size': 1, + 'stream': True + }, + expected_args=[self.proxy], + expected_kwargs={ + 'output': 'some_output', + 'chunk_size': 1, + 'stream': True, + }) @mock.patch("openstack.image.v2.image.Image.fetch") def test_image_stage(self, mock_fetch): @@ -289,26 +294,32 @@ class TestImageProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.images, image.Image) def test_add_tag(self): - self._verify("openstack.image.v2.image.Image.add_tag", - self.proxy.add_tag, - method_args=["image", "tag"], - expected_args=["tag"]) + self._verify2( + "openstack.image.v2.image.Image.add_tag", + self.proxy.add_tag, + method_args=["image", "tag"], + expected_args=[self.proxy, "tag"]) def test_remove_tag(self): - self._verify("openstack.image.v2.image.Image.remove_tag", - self.proxy.remove_tag, - method_args=["image", "tag"], - expected_args=["tag"]) + self._verify2( + "openstack.image.v2.image.Image.remove_tag", + self.proxy.remove_tag, + method_args=["image", "tag"], + expected_args=[self.proxy, "tag"]) def test_deactivate_image(self): - self._verify("openstack.image.v2.image.Image.deactivate", - self.proxy.deactivate_image, - method_args=["image"]) + self._verify2( + "openstack.image.v2.image.Image.deactivate", + self.proxy.deactivate_image, + method_args=["image"], + expected_args=[self.proxy]) def test_reactivate_image(self): - self._verify("openstack.image.v2.image.Image.reactivate", - self.proxy.reactivate_image, - method_args=["image"]) + self._verify2( + "openstack.image.v2.image.Image.reactivate", + self.proxy.reactivate_image, + method_args=["image"], + expected_args=[self.proxy]) def test_member_create(self): self.verify_create(self.proxy.add_member, member.Member, diff --git a/openstack/tests/unit/message/v2/test_proxy.py b/openstack/tests/unit/message/v2/test_proxy.py index c6866de4d..540b91359 100644 --- a/openstack/tests/unit/message/v2/test_proxy.py +++ b/openstack/tests/unit/message/v2/test_proxy.py @@ -50,10 +50,11 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): def test_message_post(self, mock_get_resource): message_obj = message.Message(queue_name="test_queue") mock_get_resource.return_value = message_obj - self._verify("openstack.message.v2.message.Message.post", - self.proxy.post_message, - method_args=["test_queue", ["msg1", "msg2"]], - expected_args=[["msg1", "msg2"]]) + self._verify2( + "openstack.message.v2.message.Message.post", + self.proxy.post_message, + method_args=["test_queue", ["msg1", "msg2"]], + expected_args=[self.proxy, ["msg1", "msg2"]]) mock_get_resource.assert_called_once_with(message.Message, None, queue_name="test_queue") @@ -128,10 +129,12 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): queue_name="test_queue") def test_subscription_create(self): - self._verify("openstack.message.v2.subscription.Subscription.create", - self.proxy.create_subscription, - method_args=["test_queue"], - expected_kwargs={"base_path": None}) + self._verify2( + "openstack.message.v2.subscription.Subscription.create", + self.proxy.create_subscription, + method_args=["test_queue"], + expected_args=[self.proxy], + expected_kwargs={"base_path": None}) @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_subscription_get(self, mock_get_resource): @@ -178,10 +181,12 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): queue_name="test_queue") def test_claim_create(self): - self._verify("openstack.message.v2.claim.Claim.create", - self.proxy.create_claim, - method_args=["test_queue"], - expected_kwargs={"base_path": None}) + self._verify2( + "openstack.message.v2.claim.Claim.create", + self.proxy.create_claim, + method_args=["test_queue"], + expected_args=[self.proxy], + expected_kwargs={"base_path": None}) def test_claim_get(self): self._verify2("openstack.proxy.Proxy._get", diff --git a/openstack/tests/unit/network/v2/test_proxy.py b/openstack/tests/unit/network/v2/test_proxy.py index 097da6148..00eddda0e 100644 --- a/openstack/tests/unit/network/v2/test_proxy.py +++ b/openstack/tests/unit/network/v2/test_proxy.py @@ -891,11 +891,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.add_interface", - self.proxy.add_interface_to_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"port_id": "PORT"}, - expected_kwargs={"port_id": "PORT"}) + self._verify2( + "openstack.network.v2.router.Router.add_interface", + self.proxy.add_interface_to_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"port_id": "PORT"}, + expected_args=[self.proxy], + expected_kwargs={"port_id": "PORT"}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -905,11 +907,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.add_interface", - self.proxy.add_interface_to_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"subnet_id": "SUBNET"}, - expected_kwargs={"subnet_id": "SUBNET"}) + self._verify2( + "openstack.network.v2.router.Router.add_interface", + self.proxy.add_interface_to_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"subnet_id": "SUBNET"}, + expected_args=[self.proxy], + expected_kwargs={"subnet_id": "SUBNET"}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -919,11 +923,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.remove_interface", - self.proxy.remove_interface_from_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"port_id": "PORT"}, - expected_kwargs={"port_id": "PORT"}) + self._verify2( + "openstack.network.v2.router.Router.remove_interface", + self.proxy.remove_interface_from_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"port_id": "PORT"}, + expected_args=[self.proxy], + expected_kwargs={"port_id": "PORT"}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -933,11 +939,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.remove_interface", - self.proxy.remove_interface_from_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"subnet_id": "SUBNET"}, - expected_kwargs={"subnet_id": "SUBNET"}) + self._verify2( + "openstack.network.v2.router.Router.remove_interface", + self.proxy.remove_interface_from_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"subnet_id": "SUBNET"}, + expected_args=[self.proxy], + expected_kwargs={"subnet_id": "SUBNET"}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -947,11 +955,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.add_extra_routes", - self.proxy.add_extra_routes_to_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"body": {"router": {"routes": []}}}, - expected_kwargs={"body": {"router": {"routes": []}}}) + self._verify2( + "openstack.network.v2.router.Router.add_extra_routes", + self.proxy.add_extra_routes_to_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"body": {"router": {"routes": []}}}, + expected_args=[self.proxy], + expected_kwargs={"body": {"router": {"routes": []}}}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -961,11 +971,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.remove_extra_routes", - self.proxy.remove_extra_routes_from_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"body": {"router": {"routes": []}}}, - expected_kwargs={"body": {"router": {"routes": []}}}) + self._verify2( + "openstack.network.v2.router.Router.remove_extra_routes", + self.proxy.remove_extra_routes_from_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"body": {"router": {"routes": []}}}, + expected_args=[self.proxy], + expected_kwargs={"body": {"router": {"routes": []}}}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -974,11 +986,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.add_gateway", - self.proxy.add_gateway_to_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"foo": "bar"}, - expected_kwargs={"foo": "bar"}) + self._verify2( + "openstack.network.v2.router.Router.add_gateway", + self.proxy.add_gateway_to_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"foo": "bar"}, + expected_args=[self.proxy], + expected_kwargs={"foo": "bar"}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") @mock.patch.object(proxy_base.Proxy, '_get_resource') @@ -987,11 +1001,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify("openstack.network.v2.router.Router.remove_gateway", - self.proxy.remove_gateway_from_router, - method_args=["FAKE_ROUTER"], - method_kwargs={"foo": "bar"}, - expected_kwargs={"foo": "bar"}) + self._verify2( + "openstack.network.v2.router.Router.remove_gateway", + self.proxy.remove_gateway_from_router, + method_args=["FAKE_ROUTER"], + method_kwargs={"foo": "bar"}, + expected_args=[self.proxy], + expected_kwargs={"foo": "bar"}) mock_get.assert_called_once_with(router.Router, "FAKE_ROUTER") def test_router_hosting_l3_agents_list(self): @@ -1341,11 +1357,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_set_tags(self): x_network = network.Network.new(id='NETWORK_ID') - self._verify('openstack.network.v2.network.Network.set_tags', - self.proxy.set_tags, - method_args=[x_network, ['TAG1', 'TAG2']], - expected_args=[['TAG1', 'TAG2']], - expected_result=mock.sentinel.result_set_tags) + self._verify2( + 'openstack.network.v2.network.Network.set_tags', + self.proxy.set_tags, + method_args=[x_network, ['TAG1', 'TAG2']], + expected_args=[self.proxy, ['TAG1', 'TAG2']], + expected_result=mock.sentinel.result_set_tags) @mock.patch('openstack.network.v2.network.Network.set_tags') def test_set_tags_resource_without_tag_suport(self, mock_set_tags): diff --git a/openstack/tests/unit/test_proxy_base.py b/openstack/tests/unit/test_proxy_base.py index 9e904ae18..b36fa4770 100644 --- a/openstack/tests/unit/test_proxy_base.py +++ b/openstack/tests/unit/test_proxy_base.py @@ -55,22 +55,32 @@ class TestProxyBase(base.TestCase): expected_result=None): with mock.patch(mock_method) as mocked: mocked.return_value = expected_result - if any([method_args, method_kwargs, - expected_args, expected_kwargs]): + if any([ + method_args, + method_kwargs, + expected_args, + expected_kwargs, + ]): method_args = method_args or () method_kwargs = method_kwargs or {} expected_args = expected_args or () expected_kwargs = expected_kwargs or {} if method_result: - self.assertEqual(method_result, test_method(*method_args, - **method_kwargs)) + self.assertEqual( + method_result, + test_method(*method_args, **method_kwargs), + ) else: - self.assertEqual(expected_result, test_method(*method_args, - **method_kwargs)) + self.assertEqual( + expected_result, + test_method(*method_args, **method_kwargs), + ) + # Check how the mock was called in detail - (called_args, called_kwargs) = mocked.call_args + called_args, called_kwargs = mocked.call_args self.assertEqual(expected_args, list(called_args)) + # NOTE(gtema): if base_path is not in expected_kwargs or empty # exclude it from the comparison, since some methods might # still invoke method with None value @@ -88,6 +98,7 @@ class TestProxyBase(base.TestCase): if ignore_missing is None: expected_kwargs.pop('ignore_missing', None) called_kwargs.pop('ignore_missing', None) + self.assertDictEqual(expected_kwargs, called_kwargs) else: self.assertEqual(expected_result, test_method()) @@ -275,4 +286,4 @@ class TestProxyBase(base.TestCase): mock_method="openstack.resource.wait_for_status", **kwargs, ): - self._verify(mock_method, test_method, **kwargs) + self._verify2(mock_method, test_method, **kwargs) From 0c9742e202a31c45106865e210b812ce7f01c933 Mon Sep 17 00:00:00 2001 From: Artem Goncharov Date: Mon, 10 May 2021 12:07:10 +0200 Subject: [PATCH 12/16] Extend functional test of image Add few invocations of the tagging funcitonality on the image. Since image resource already include TagMixin there is no need (and actually harm) to include tags attribute explicitly - drop it. Change-Id: Ie6564e03062763c83eeefb1e5b26ea4d873dbc99 --- openstack/image/v2/image.py | 2 -- .../tests/functional/image/v2/test_image.py | 21 +++++++++++++++++-- 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/openstack/image/v2/image.py b/openstack/image/v2/image.py index 4e6881a3f..bbf700a31 100644 --- a/openstack/image/v2/image.py +++ b/openstack/image/v2/image.py @@ -78,8 +78,6 @@ class Image(resource.Resource, resource.TagMixin, _download.DownloadMixin): #: The algorithm used to compute a secure hash of the image data #: for this image hash_algo = resource.Body('os_hash_algo') - #: List of tags for this image. - tags = resource.Body('tags') #: The hexdigest of the secure hash of the image data computed using #: the algorithm whose name is the value of the os_hash_algo property. hash_value = resource.Body('os_hash_value') diff --git a/openstack/tests/functional/image/v2/test_image.py b/openstack/tests/functional/image/v2/test_image.py index 3635b6a72..530f161a5 100644 --- a/openstack/tests/functional/image/v2/test_image.py +++ b/openstack/tests/functional/image/v2/test_image.py @@ -28,7 +28,7 @@ class TestImage(base.BaseFunctionalTest): self.conn = connection.from_config( cloud_name=base.TEST_CLOUD_NAME, options=opts) - self.img = self.conn.image.upload_image( + self.img = self.conn.image.create_image( name=TEST_IMAGE_NAME, disk_format='raw', container_format='bare', @@ -37,7 +37,9 @@ class TestImage(base.BaseFunctionalTest): # we need to just replace the image upload code with the stuff # from shade. Figuring out mapping the crap-tastic arbitrary # extra key-value pairs into Resource is going to be fun. - properties='{"description": "This is not an image"}', + properties=dict( + description="This is not an image" + ), data=open('CONTRIBUTING.rst', 'r') ) self.addCleanup(self.conn.image.delete_image, self.img) @@ -65,3 +67,18 @@ class TestImage(base.BaseFunctionalTest): def test_list_tasks(self): tasks = self.conn.image.tasks() self.assertIsNotNone(tasks) + + def test_tags(self): + img = self.conn.image.get_image(self.img) + self.conn.image.add_tag(img, 't1') + self.conn.image.add_tag(img, 't2') + # Ensure list with array of tags return us our image + list_img = list(self.conn.image.images(tag=['t1', 't2']))[0] + self.assertEqual(img.id, list_img.id) + self.assertIn('t1', list_img.tags) + self.assertIn('t2', list_img.tags) + self.conn.image.remove_tag(img, 't1') + # Refetch img to verify tags + img = self.conn.image.get_image(self.img) + self.assertIn('t2', img.tags) + self.assertNotIn('t1', img.tags) From 8ed2d1001920a9d29f3cbef2a02b3ceb38ba3da0 Mon Sep 17 00:00:00 2001 From: "wu.shiming" Date: Wed, 12 May 2021 09:54:38 +0800 Subject: [PATCH 13/16] setup.cfg: Replace dashes with underscores Setuptools v54.1.0 introduces a warning that the use of dash-separated options in 'setup.cfg' will not be supported in a future version [1]. Get ahead of the issue by replacing the dashes with underscores. Without this, we see 'UserWarning' messages like the following on new enough versions of setuptools: UserWarning: Usage of dash-separated 'description-file' will not be supported in future versions. Please use the underscore name 'description_file' instead [1] https://github.com/pypa/setuptools/commit/a2e9ae4cb Change-Id: I6974592dc7cd44a749986ec0373afddc48d43b78 --- setup.cfg | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/setup.cfg b/setup.cfg index a635769c4..0c8ae0e52 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,11 +1,11 @@ [metadata] name = openstacksdk summary = An SDK for building applications to work with OpenStack -description-file = +description_file = README.rst author = OpenStack -author-email = openstack-discuss@lists.openstack.org -home-page = https://docs.openstack.org/openstacksdk/ +author_email = openstack-discuss@lists.openstack.org +home_page = https://docs.openstack.org/openstacksdk/ classifier = Environment :: OpenStack Intended Audience :: Information Technology @@ -17,7 +17,7 @@ classifier = Programming Language :: Python :: 3.6 Programming Language :: Python :: 3.7 Programming Language :: Python :: 3.8 -python-requires = >=3.6 +python_requires = >=3.6 [files] packages = From 3fd70ddc0522bea26986694113c7df7fd260c5bf Mon Sep 17 00:00:00 2001 From: Ryan Zimmerman Date: Tue, 11 May 2021 23:05:52 -0700 Subject: [PATCH 14/16] Add compute microversion 2.79 Compute 2.79 [1] added support for specifying the delete_on_termination field in the request body, which configures whether a volume is deleted when the server is destroyed. [1] https://docs.openstack.org/nova/latest/reference/api-microversion-history.html#maximum-in-train Change-Id: I52e9f5d888a242ec564b90c8caac86ae02e8f596 --- openstack/compute/v2/volume_attachment.py | 6 ++++-- openstack/tests/unit/compute/v2/test_volume_attachment.py | 3 +++ 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/openstack/compute/v2/volume_attachment.py b/openstack/compute/v2/volume_attachment.py index 770395c7d..45fc45bc2 100644 --- a/openstack/compute/v2/volume_attachment.py +++ b/openstack/compute/v2/volume_attachment.py @@ -39,5 +39,7 @@ class VolumeAttachment(resource.Resource): attachment_id = resource.Body('attachment_id', alternate_id=True) #: Virtual device tags for the attachment. tag = resource.Body('tag') - # tag introduced in 2.70 - _max_microversion = '2.70' + #: Indicates whether to delete the volume when server is destroyed + delete_on_termination = resource.Body('delete_on_termination') + # delete_on_termination introduced in 2.79 + _max_microversion = '2.79' diff --git a/openstack/tests/unit/compute/v2/test_volume_attachment.py b/openstack/tests/unit/compute/v2/test_volume_attachment.py index 2eb473d4a..03d031c1f 100644 --- a/openstack/tests/unit/compute/v2/test_volume_attachment.py +++ b/openstack/tests/unit/compute/v2/test_volume_attachment.py @@ -19,6 +19,7 @@ EXAMPLE = { 'id': '2', 'volume_id': '3', 'tag': '4', + 'delete_on_termination': 'true', } @@ -46,3 +47,5 @@ class TestServerInterface(base.TestCase): self.assertEqual(EXAMPLE['id'], sot.id) self.assertEqual(EXAMPLE['volume_id'], sot.volume_id) self.assertEqual(EXAMPLE['tag'], sot.tag) + self.assertEqual(EXAMPLE['delete_on_termination'], + sot.delete_on_termination) From 40cc84d53d8ddf2af333845d12bef9fc7a65c447 Mon Sep 17 00:00:00 2001 From: Polina Gubina Date: Thu, 13 May 2021 15:07:32 +0300 Subject: [PATCH 15/16] Add IPsecSiteConnection resource and proxy layer functionality for it Change-Id: I04b017f483f07e041cc429706cd92a39900d5eb6 --- doc/source/user/proxies/network.rst | 9 ++ doc/source/user/resources/network/index.rst | 1 + .../network/v2/ipsec_site_connection.rst | 13 +++ openstack/network/v2/_proxy.py | 96 ++++++++++++++++ openstack/network/v2/ipsec_site_connection.py | 105 ++++++++++++++++++ .../network/v2/test_ipsec_site_connection.py | 80 +++++++++++++ openstack/tests/unit/network/v2/test_proxy.py | 29 +++++ 7 files changed, 333 insertions(+) create mode 100644 doc/source/user/resources/network/v2/ipsec_site_connection.rst create mode 100644 openstack/network/v2/ipsec_site_connection.py create mode 100644 openstack/tests/unit/network/v2/test_ipsec_site_connection.py diff --git a/doc/source/user/proxies/network.rst b/doc/source/user/proxies/network.rst index d8eb64e51..3c5f76a76 100644 --- a/doc/source/user/proxies/network.rst +++ b/doc/source/user/proxies/network.rst @@ -234,6 +234,15 @@ VPN Operations :members: create_vpn_service, update_vpn_service, delete_vpn_service, get_vpn_service, find_vpn_service, vpn_services +IPSecSiteConnection Operations +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. autoclass:: openstack.network.v2._proxy.Proxy + :noindex: + :members: create_vpn_ipsec_site_connection, update_vpn_ipsec_site_connection, + delete_vpn_ipsec_site_connection, get_vpn_ipsec_site_connection, + find_vpn_ipsec_site_connection, vpn_ipsec_site_connections + Extension Operations ^^^^^^^^^^^^^^^^^^^^ diff --git a/doc/source/user/resources/network/index.rst b/doc/source/user/resources/network/index.rst index 3884de78e..75fb5d928 100644 --- a/doc/source/user/resources/network/index.rst +++ b/doc/source/user/resources/network/index.rst @@ -13,6 +13,7 @@ Network Resources v2/flavor v2/floating_ip v2/health_monitor + v2/ipsec_site_connection v2/listener v2/load_balancer v2/metering_label diff --git a/doc/source/user/resources/network/v2/ipsec_site_connection.rst b/doc/source/user/resources/network/v2/ipsec_site_connection.rst new file mode 100644 index 000000000..3750344e7 --- /dev/null +++ b/doc/source/user/resources/network/v2/ipsec_site_connection.rst @@ -0,0 +1,13 @@ +openstack.network.v2.ipsec_site_connection +========================================== + +.. automodule:: openstack.network.v2.ipsec_site_connection + +The IPSecSiteConnection Class +----------------------------- + +The ``IPSecSiteConnection`` class inherits from +:class:`~openstack.resource.Resource`. + +.. autoclass:: openstack.network.v2.ipsec_site_connection.IPSecSiteConnection + :members: diff --git a/openstack/network/v2/_proxy.py b/openstack/network/v2/_proxy.py index 8d2fecdc9..ac9d735d4 100644 --- a/openstack/network/v2/_proxy.py +++ b/openstack/network/v2/_proxy.py @@ -24,6 +24,8 @@ from openstack.network.v2 import firewall_rule as _firewall_rule from openstack.network.v2 import flavor as _flavor from openstack.network.v2 import floating_ip as _floating_ip from openstack.network.v2 import health_monitor as _health_monitor +from openstack.network.v2 import ipsec_site_connection as \ + _ipsec_site_connection from openstack.network.v2 import l3_conntrack_helper as _l3_conntrack_helper from openstack.network.v2 import listener as _listener from openstack.network.v2 import load_balancer as _load_balancer @@ -951,6 +953,100 @@ class Proxy(proxy.Proxy): return self._update(_health_monitor.HealthMonitor, health_monitor, **attrs) + def create_vpn_ipsec_site_connection(self, **attrs): + """Create a new ipsec site connection from attributes + + :param dict attrs: Keyword arguments which will be used to create a + :class:`~openstack.network.v2.ipsec_site_connection. + IPSecSiteConnection`, comprised of the properties on the + IPSecSiteConnection class. + + :returns: The results of ipsec site connection creation :rtype: + :class:`~openstack.network.v2.ipsec_site_connection. + IPSecSiteConnection` + """ + return self._create(_ipsec_site_connection.IPSecSiteConnection, + **attrs) + + def find_vpn_ipsec_site_connection(self, name_or_id, + ignore_missing=True, **args): + """Find a single ipsec site connection + + :param name_or_id: The name or ID of an ipsec site connection. + :param bool ignore_missing: When set to ``False`` :class:`~openstack. + exceptions.ResourceNotFound` will be raised when the resource does + not exist.When set to ``True``, None will be returned when + attempting to find a nonexistent resource. + :param dict args: Any additional parameters to be passed into + underlying methods such as query filters. + :returns: One :class:`~openstack.network.v2.ipsec_site_connection. + IPSecSiteConnection` or None + """ + return self._find(_ipsec_site_connection.IPSecSiteConnection, + name_or_id, ignore_missing=ignore_missing, **args) + + def get_vpn_ipsec_site_connection(self, ipsec_site_connection): + """Get a single ipsec site connection + + :param ipsec_site_connection: The value can be the ID of an ipsec site + connection or a :class:`~openstack.network.v2. + ipsec_site_connection.IPSecSiteConnection` instance. + + :returns: One :class:`~openstack.network.v2.ipsec_site_connection. + IPSecSiteConnection` + :raises: :class:`~openstack.exceptions.ResourceNotFound` + when no resource can be found. + """ + return self._get(_ipsec_site_connection.IPSecSiteConnection, + ipsec_site_connection) + + def vpn_ipsec_site_connections(self, **query): + """Return a generator of ipsec site connections + + :param dict query: Optional query parameters to be sent to limit the + resources being returned. + + :returns: A generator of ipsec site connection objects + :rtype: :class:`~openstack.network.v2.ipsec_site_connection. + IPSecSiteConnection` + """ + return self._list(_ipsec_site_connection.IPSecSiteConnection, **query) + + def update_vpn_ipsec_site_connection(self, ipsec_site_connection, **attrs): + """Update a ipsec site connection + + :ipsec_site_connection: Either the id of an ipsec site connection or + a :class:`~openstack.network.v2.ipsec_site_connection. + IPSecSiteConnection` instance. + :param dict attrs: The attributes to update on the ipsec site + connection represented by ``ipsec_site_connection``. + + :returns: The updated ipsec site connection + :rtype: :class:`~openstack.network.v2.ipsec_site_connection. + IPSecSiteConnection` + """ + return self._update(_ipsec_site_connection.IPSecSiteConnection, + ipsec_site_connection, **attrs) + + def delete_vpn_ipsec_site_connection(self, ipsec_site_connection, + ignore_missing=True): + """Delete a ipsec site connection + + :param ipsec_site_connection: The value can be either the ID of an + ipsec site connection, or a :class:`~openstack.network.v2. + ipsec_site_connection.IPSecSiteConnection` instance. + :param bool ignore_missing: + When set to ``False`` :class:`~openstack.exceptions. + ResourceNotFound` will be raised when the ipsec site connection + does not exist. + When set to ``True``, no exception will be set when attempting to + delete a nonexistent ipsec site connection. + + :returns: ``None`` + """ + self._delete(_ipsec_site_connection.IPSecSiteConnection, + ipsec_site_connection, ignore_missing=ignore_missing) + def create_listener(self, **attrs): """Create a new listener from attributes diff --git a/openstack/network/v2/ipsec_site_connection.py b/openstack/network/v2/ipsec_site_connection.py new file mode 100644 index 000000000..1b2aa29e6 --- /dev/null +++ b/openstack/network/v2/ipsec_site_connection.py @@ -0,0 +1,105 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from openstack import resource + + +class IPSecSiteConnection(resource.Resource): + resource_key = 'ipsec_site_connection' + resources_key = 'ipsec_site_connections' + base_path = '/vpn/ipsec-site-connections' + + # capabilities + allow_create = True + allow_fetch = True + allow_commit = True + allow_delete = True + allow_list = True + + # Properties + #: The dead peer detection (DPD) action. + # A valid value is clear, hold, restart, + # disabled, or restart-by-peer. Default value is hold. + action = resource.Body('action') + #: The authentication mode. A valid value + # is psk, which is the default. + auth_mode = resource.Body('auth_mode') + #: A human-readable description for the resource. + # Default is an empty string. + description = resource.Body('description') + #: A dictionary with dead peer detection (DPD) protocol controls. + dpd = resource.Body('dpd', type=dict) + #: The administrative state of the resource, + # which is up (true) or down (false). + is_admin_state_up = resource.Body('admin_state_up', type=bool) + #: The ID of the IKE policy. + ikepolicy_id = resource.Body('ikepolicy_id') + #: Indicates whether this VPN can only respond + # to connections or both respond + # to and initiate connections. A valid value is + # response- only or bi-directional. Default is bi-directional. + initiator = resource.Body('initiator') + #: The ID of the IPsec policy. + ipsecpolicy_id = resource.Body('ipsecpolicy_id') + #: The dead peer detection (DPD) interval, in seconds. + # A valid value is a positive integer. Default is 30. + interval = resource.Body('interval', type=int) + #: The ID for the endpoint group that contains + # private subnets for the local side of the connection. + # Yo must specify this parameter with the + # peer_ep_group_id parameter unless in backward- compatible + # mode where peer_cidrs is provided with + # a subnet_id for the VPN service. + local_ep_group_id = resource.Body('local_ep_group_id') + #: The peer gateway public IPv4 or IPv6 address or FQDN. + peer_address = resource.Body('peer_address') + #: An ID to be used instead of the external IP address for + # a virtual router used in traffic between + # instances on different networks in east-west traffic. + # Most often, local ID would be domain + # name, email address, etc. If this is not configured + # then the external IP address will be used as the ID. + local_id = resource.Body('local_id') + #: The maximum transmission unit (MTU) + # value to address fragmentation. Minimum value + # is 68 for IPv4, and 1280 for IPv6. + mtu = resource.Body('mtu', type=int) + #: Human-readable name of the resource. Default is an empty string. + name = resource.Body('name') + #: The peer router identity for authentication. + # A valid value is an IPv4 address, IPv6 address, e-mail address, + # key ID, or FQDN. Typically, this value matches + # the peer_address value. + peer_id = resource.Body('peer_id') + #: (Deprecated) Unique list of valid peer private + # CIDRs in the form < net_address > / < prefix > . + peer_cidrs = resource.Body('peer_cidrs', type=list) + #: The ID of the project. + project_id = resource.Body('tenant_id') + #: The pre-shared key. A valid value is any string. + psk = resource.Body('psk') + #: The ID for the endpoint group that contains + # private CIDRs in the form < net_address > / < prefix > + # for the peer side of the connection. You must + # specify this parameter with the local_ep_group_id + # parameter unless in backward-compatible mode + # where peer_cidrs is provided with a subnet_id for the VPN service. + peer_ep_group_id = resource.Body('peer_ep_group_id') + #: The route mode. A valid value is static, which is the default. + route_mode = resource.Body('route_mode') + #: The dead peer detection (DPD) timeout + # in seconds. A valid value is a + # positive integer that is greater + # than the DPD interval value. Default is 120. + timeout = resource.Body('timeout', type=int) + #: The ID of the VPN service. + vpnservice_id = resource.Body('vpnservice_id') diff --git a/openstack/tests/unit/network/v2/test_ipsec_site_connection.py b/openstack/tests/unit/network/v2/test_ipsec_site_connection.py new file mode 100644 index 000000000..bee693bf6 --- /dev/null +++ b/openstack/tests/unit/network/v2/test_ipsec_site_connection.py @@ -0,0 +1,80 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from openstack.network.v2 import ipsec_site_connection +from openstack.tests.unit import base + + +IDENTIFIER = 'IDENTIFIER' +EXAMPLE = { + "admin_state_up": True, + "auth_mode": "1", + "ikepolicy_id": "2", + "vpnservice_id": "3", + "local_ep_group_id": "4", + "peer_address": "5", + "route_mode": "6", + "ipsecpolicy_id": "7", + "peer_id": "8", + "psk": "9", + "description": "10", + "initiator": "11", + "peer_cidrs": ['1', '2'], + "name": "12", + "tenant_id": "13", + "interval": 5, + "mtu": 5, + "peer_ep_group_id": "14", + "dpd": {'a': 5}, + "timeout": 16, + "action": "17", + "local_id": "18" +} + + +class TestIPSecSiteConnection(base.TestCase): + + def test_basic(self): + sot = ipsec_site_connection.IPSecSiteConnection() + self.assertEqual('ipsec_site_connection', sot.resource_key) + self.assertEqual('ipsec_site_connections', sot.resources_key) + self.assertEqual('/vpn/ipsec-site-connections', sot.base_path) + self.assertTrue(sot.allow_create) + self.assertTrue(sot.allow_fetch) + self.assertTrue(sot.allow_commit) + self.assertTrue(sot.allow_delete) + self.assertTrue(sot.allow_list) + + def test_make_it(self): + sot = ipsec_site_connection.IPSecSiteConnection(**EXAMPLE) + self.assertTrue(sot.is_admin_state_up) + self.assertEqual(EXAMPLE['auth_mode'], sot.auth_mode) + self.assertEqual(EXAMPLE['ikepolicy_id'], sot.ikepolicy_id) + self.assertEqual(EXAMPLE['vpnservice_id'], sot.vpnservice_id) + self.assertEqual(EXAMPLE['local_ep_group_id'], sot.local_ep_group_id) + self.assertEqual(EXAMPLE['peer_address'], sot.peer_address) + self.assertEqual(EXAMPLE['route_mode'], sot.route_mode) + self.assertEqual(EXAMPLE['ipsecpolicy_id'], sot.ipsecpolicy_id) + self.assertEqual(EXAMPLE['peer_id'], sot.peer_id) + self.assertEqual(EXAMPLE['psk'], sot.psk) + self.assertEqual(EXAMPLE['description'], sot.description) + self.assertEqual(EXAMPLE['initiator'], sot.initiator) + self.assertEqual(EXAMPLE['peer_cidrs'], sot.peer_cidrs) + self.assertEqual(EXAMPLE['name'], sot.name) + self.assertEqual(EXAMPLE['tenant_id'], sot.project_id) + self.assertEqual(EXAMPLE['interval'], sot.interval) + self.assertEqual(EXAMPLE['mtu'], sot.mtu) + self.assertEqual(EXAMPLE['peer_ep_group_id'], sot.peer_ep_group_id) + self.assertEqual(EXAMPLE['dpd'], sot.dpd) + self.assertEqual(EXAMPLE['timeout'], sot.timeout) + self.assertEqual(EXAMPLE['action'], sot.action) + self.assertEqual(EXAMPLE['local_id'], sot.local_id) diff --git a/openstack/tests/unit/network/v2/test_proxy.py b/openstack/tests/unit/network/v2/test_proxy.py index 9772d995b..369467b81 100644 --- a/openstack/tests/unit/network/v2/test_proxy.py +++ b/openstack/tests/unit/network/v2/test_proxy.py @@ -26,6 +26,7 @@ from openstack.network.v2 import firewall_rule from openstack.network.v2 import flavor from openstack.network.v2 import floating_ip from openstack.network.v2 import health_monitor +from openstack.network.v2 import ipsec_site_connection from openstack.network.v2 import l3_conntrack_helper from openstack.network.v2 import listener from openstack.network.v2 import load_balancer @@ -224,6 +225,34 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_update(self.proxy.update_health_monitor, health_monitor.HealthMonitor) + def test_ipsec_site_connection_create_attrs(self): + self.verify_create(self.proxy.create_vpn_ipsec_site_connection, + ipsec_site_connection.IPSecSiteConnection) + + def test_ipsec_site_connection_delete(self): + self.verify_delete(self.proxy.delete_vpn_ipsec_site_connection, + ipsec_site_connection.IPSecSiteConnection, False) + + def test_ipsec_site_connection_delete_ignore(self): + self.verify_delete(self.proxy.delete_vpn_ipsec_site_connection, + ipsec_site_connection.IPSecSiteConnection, True) + + def test_ipsec_site_connection_find(self): + self.verify_find(self.proxy.find_vpn_ipsec_site_connection, + ipsec_site_connection.IPSecSiteConnection) + + def test_ipsec_site_connection_get(self): + self.verify_get(self.proxy.get_vpn_ipsec_site_connection, + ipsec_site_connection.IPSecSiteConnection) + + def test_ipsec_site_connections(self): + self.verify_list(self.proxy.vpn_ipsec_site_connections, + ipsec_site_connection.IPSecSiteConnection) + + def test_ipsec_site_connection_update(self): + self.verify_update(self.proxy.update_vpn_ipsec_site_connection, + ipsec_site_connection.IPSecSiteConnection) + def test_listener_create_attrs(self): self.verify_create(self.proxy.create_listener, listener.Listener) From 2e7b48ff4ebb59872d000cde20bacae74b0849d9 Mon Sep 17 00:00:00 2001 From: Stephen Finucane Date: Mon, 26 Apr 2021 12:19:12 +0100 Subject: [PATCH 16/16] tests: Rename 'TestProxyBase._verify2' to '_verify' Change-Id: I9d055751d631fa8c951f57d680448f9df26061a1 Signed-off-by: Stephen Finucane --- .../tests/unit/block_storage/v2/test_proxy.py | 4 +- .../tests/unit/block_storage/v3/test_proxy.py | 16 +- .../tests/unit/clustering/v1/test_proxy.py | 72 ++--- openstack/tests/unit/compute/v2/test_proxy.py | 218 +++++++------- .../tests/unit/database/v1/test_proxy.py | 26 +- openstack/tests/unit/dns/v2/test_proxy.py | 32 +- openstack/tests/unit/image/v2/test_proxy.py | 168 ++++++----- .../tests/unit/load_balancer/v2/test_proxy.py | 82 ++--- openstack/tests/unit/message/v2/test_proxy.py | 91 +++--- openstack/tests/unit/network/v2/test_proxy.py | 281 +++++++++--------- .../tests/unit/object_store/v1/test_proxy.py | 37 +-- .../tests/unit/orchestration/v1/test_proxy.py | 127 ++++---- openstack/tests/unit/test_proxy_base.py | 54 +--- 13 files changed, 610 insertions(+), 598 deletions(-) diff --git a/openstack/tests/unit/block_storage/v2/test_proxy.py b/openstack/tests/unit/block_storage/v2/test_proxy.py index a77e08aab..ffb49e030 100644 --- a/openstack/tests/unit/block_storage/v2/test_proxy.py +++ b/openstack/tests/unit/block_storage/v2/test_proxy.py @@ -88,7 +88,7 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_volume, volume.Volume, True) def test_volume_extend(self): - self._verify2( + self._verify( "openstack.block_storage.v2.volume.Volume.extend", self.proxy.extend_volume, method_args=["value", "new-size"], @@ -142,7 +142,7 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): # NOTE: mock has_service self.proxy._connection = mock.Mock() self.proxy._connection.has_service = mock.Mock(return_value=True) - self._verify2( + self._verify( 'openstack.block_storage.v2.backup.Backup.restore', self.proxy.restore_backup, method_args=['volume_id'], diff --git a/openstack/tests/unit/block_storage/v3/test_proxy.py b/openstack/tests/unit/block_storage/v3/test_proxy.py index 85a5356a5..044832a7a 100644 --- a/openstack/tests/unit/block_storage/v3/test_proxy.py +++ b/openstack/tests/unit/block_storage/v3/test_proxy.py @@ -82,7 +82,7 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): def test_type_extra_specs_update(self): kwargs = {"a": "1", "b": "2"} id = "an_id" - self._verify2( + self._verify( "openstack.block_storage.v3.type.Type.set_extra_specs", self.proxy.update_type_extra_specs, method_args=[id], @@ -94,7 +94,7 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): expected_result=kwargs) def test_type_extra_specs_delete(self): - self._verify2( + self._verify( "openstack.block_storage.v3.type.Type.delete_extra_specs", self.proxy.delete_type_extra_specs, expected_result=None, @@ -156,21 +156,21 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_volume, volume.Volume, True) def test_volume_extend(self): - self._verify2( + self._verify( "openstack.block_storage.v3.volume.Volume.extend", self.proxy.extend_volume, method_args=["value", "new-size"], expected_args=[self.proxy, "new-size"]) def test_volume_set_readonly_no_argument(self): - self._verify2( + self._verify( "openstack.block_storage.v3.volume.Volume.set_readonly", self.proxy.set_volume_readonly, method_args=["value"], expected_args=[self.proxy, True]) def test_volume_set_readonly_false(self): - self._verify2( + self._verify( "openstack.block_storage.v3.volume.Volume.set_readonly", self.proxy.set_volume_readonly, method_args=["value", False], @@ -180,13 +180,13 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): self._verify("openstack.block_storage.v3.volume.Volume.retype", self.proxy.retype_volume, method_args=["value", "rbd"], - expected_args=["rbd", "never"]) + expected_args=[self.proxy, "rbd", "never"]) def test_volume_retype_with_migration_policy(self): self._verify("openstack.block_storage.v3.volume.Volume.retype", self.proxy.retype_volume, method_args=["value", "rbd", "on-demand"], - expected_args=["rbd", "on-demand"]) + expected_args=[self.proxy, "rbd", "on-demand"]) def test_backend_pools(self): self.verify_list(self.proxy.backend_pools, stats.Pools) @@ -242,7 +242,7 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase): # NOTE: mock has_service self.proxy._connection = mock.Mock() self.proxy._connection.has_service = mock.Mock(return_value=True) - self._verify2( + self._verify( 'openstack.block_storage.v3.backup.Backup.restore', self.proxy.restore_backup, method_args=['volume_id'], diff --git a/openstack/tests/unit/clustering/v1/test_proxy.py b/openstack/tests/unit/clustering/v1/test_proxy.py index f06be57c5..7c8f62dc5 100644 --- a/openstack/tests/unit/clustering/v1/test_proxy.py +++ b/openstack/tests/unit/clustering/v1/test_proxy.py @@ -91,7 +91,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_cluster, cluster.Cluster, True) def test_cluster_force_delete(self): - self._verify2( + self._verify( "openstack.clustering.v1.cluster.Cluster.force_delete", self.proxy.delete_cluster, method_args=["value", False, True], @@ -119,7 +119,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_resize_cluster(self, mock_find): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') mock_find.return_value = mock_cluster - self._verify2( + self._verify( "openstack.clustering.v1.cluster.Cluster.resize", self.proxy.resize_cluster, method_args=["FAKE_CLUSTER"], @@ -131,7 +131,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_resize_cluster_with_obj(self): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') - self._verify2( + self._verify( "openstack.clustering.v1.cluster.Cluster.resize", self.proxy.resize_cluster, method_args=[mock_cluster], @@ -151,7 +151,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_cluster_check(self, mock_get): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') mock_get.return_value = mock_cluster - self._verify2( + self._verify( "openstack.clustering.v1.cluster.Cluster.check", self.proxy.check_cluster, method_args=["FAKE_CLUSTER"], @@ -162,7 +162,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_cluster_recover(self, mock_get): mock_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') mock_get.return_value = mock_cluster - self._verify2( + self._verify( "openstack.clustering.v1.cluster.Cluster.recover", self.proxy.recover_cluster, method_args=["FAKE_CLUSTER"], @@ -179,7 +179,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): self.verify_delete(self.proxy.delete_node, node.Node, True) def test_node_force_delete(self): - self._verify2( + self._verify( "openstack.clustering.v1.node.Node.force_delete", self.proxy.delete_node, method_args=["value", False, True], @@ -192,13 +192,13 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): self.verify_get(self.proxy.get_node, node.Node) def test_node_get_with_details(self): - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_node, - method_args=['NODE_ID'], - method_kwargs={'details': True}, - expected_args=[node.NodeDetail], - expected_kwargs={'node_id': 'NODE_ID', - 'requires_id': False}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_node, + method_args=['NODE_ID'], + method_kwargs={'details': True}, + expected_args=[node.NodeDetail], + expected_kwargs={'node_id': 'NODE_ID', 'requires_id': False}) def test_nodes(self): self.verify_list(self.proxy.nodes, node.Node, @@ -212,7 +212,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_node_check(self, mock_get): mock_node = node.Node.new(id='FAKE_NODE') mock_get.return_value = mock_node - self._verify2( + self._verify( "openstack.clustering.v1.node.Node.check", self.proxy.check_node, method_args=["FAKE_NODE"], @@ -223,7 +223,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_node_recover(self, mock_get): mock_node = node.Node.new(id='FAKE_NODE') mock_get.return_value = mock_node - self._verify2( + self._verify( "openstack.clustering.v1.node.Node.recover", self.proxy.recover_node, method_args=["FAKE_NODE"], @@ -234,7 +234,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_node_adopt(self, mock_get): mock_node = node.Node.new() mock_get.return_value = mock_node - self._verify2( + self._verify( "openstack.clustering.v1.node.Node.adopt", self.proxy.adopt_node, method_kwargs={"preview": False, "foo": "bar"}, @@ -247,7 +247,7 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): def test_node_adopt_preview(self, mock_get): mock_node = node.Node.new() mock_get.return_value = mock_node - self._verify2( + self._verify( "openstack.clustering.v1.node.Node.adopt", self.proxy.adopt_node, method_kwargs={"preview": True, "foo": "bar"}, @@ -294,29 +294,29 @@ class TestClusterProxy(test_proxy_base.TestProxyBase): fake_cluster = cluster.Cluster.new(id='FAKE_CLUSTER') # ClusterPolicy object as input - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_cluster_policy, - method_args=[fake_policy, "FAKE_CLUSTER"], - expected_args=[cluster_policy.ClusterPolicy, - fake_policy], - expected_kwargs={'cluster_id': 'FAKE_CLUSTER'}, - expected_result=fake_policy) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_cluster_policy, + method_args=[fake_policy, "FAKE_CLUSTER"], + expected_args=[cluster_policy.ClusterPolicy, fake_policy], + expected_kwargs={'cluster_id': 'FAKE_CLUSTER'}, + expected_result=fake_policy) # Policy ID as input - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_cluster_policy, - method_args=["FAKE_POLICY", "FAKE_CLUSTER"], - expected_args=[cluster_policy.ClusterPolicy, - "FAKE_POLICY"], - expected_kwargs={"cluster_id": "FAKE_CLUSTER"}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_cluster_policy, + method_args=["FAKE_POLICY", "FAKE_CLUSTER"], + expected_args=[cluster_policy.ClusterPolicy, "FAKE_POLICY"], + expected_kwargs={"cluster_id": "FAKE_CLUSTER"}) # Cluster object as input - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_cluster_policy, - method_args=["FAKE_POLICY", fake_cluster], - expected_args=[cluster_policy.ClusterPolicy, - "FAKE_POLICY"], - expected_kwargs={"cluster_id": fake_cluster}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_cluster_policy, + method_args=["FAKE_POLICY", fake_cluster], + expected_args=[cluster_policy.ClusterPolicy, "FAKE_POLICY"], + expected_kwargs={"cluster_id": fake_cluster}) def test_receiver_create(self): self.verify_create(self.proxy.create_receiver, receiver.Receiver) diff --git a/openstack/tests/unit/compute/v2/test_proxy.py b/openstack/tests/unit/compute/v2/test_proxy.py index 2dcb4adbe..a0ed8da44 100644 --- a/openstack/tests/unit/compute/v2/test_proxy.py +++ b/openstack/tests/unit/compute/v2/test_proxy.py @@ -66,7 +66,7 @@ class TestFlavor(TestComputeProxy): ) as mocked: res = flavor.Flavor() mocked.return_value = res - self._verify2( + self._verify( 'openstack.proxy.Proxy._find', self.proxy.find_flavor, method_args=['res', True, True], @@ -83,7 +83,7 @@ class TestFlavor(TestComputeProxy): ) as mocked: res = flavor.Flavor(extra_specs={'a': 'b'}) mocked.return_value = res - self._verify2( + self._verify( 'openstack.proxy.Proxy._find', self.proxy.find_flavor, method_args=['res', True], @@ -100,7 +100,7 @@ class TestFlavor(TestComputeProxy): ) as mocked: res = flavor.Flavor() mocked.return_value = res - self._verify2( + self._verify( 'openstack.proxy.Proxy._get', self.proxy.get_flavor, method_args=['res'], @@ -116,7 +116,7 @@ class TestFlavor(TestComputeProxy): ) as mocked: res = flavor.Flavor() mocked.return_value = res - self._verify2( + self._verify( 'openstack.proxy.Proxy._get', self.proxy.get_flavor, method_args=['res', True], @@ -132,7 +132,7 @@ class TestFlavor(TestComputeProxy): ) as mocked: res = flavor.Flavor(extra_specs={'a': 'b'}) mocked.return_value = res - self._verify2( + self._verify( 'openstack.proxy.Proxy._get', self.proxy.get_flavor, method_args=['res', True], @@ -193,35 +193,35 @@ class TestFlavor(TestComputeProxy): ) def test_flavor_get_access(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.get_access", self.proxy.get_flavor_access, method_args=["value"], expected_args=[self.proxy]) def test_flavor_add_tenant_access(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.add_tenant_access", self.proxy.flavor_add_tenant_access, method_args=["value", "fake-tenant"], expected_args=[self.proxy, "fake-tenant"]) def test_flavor_remove_tenant_access(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.remove_tenant_access", self.proxy.flavor_remove_tenant_access, method_args=["value", "fake-tenant"], expected_args=[self.proxy, "fake-tenant"]) def test_flavor_fetch_extra_specs(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.fetch_extra_specs", self.proxy.fetch_flavor_extra_specs, method_args=["value"], expected_args=[self.proxy]) def test_create_flavor_extra_specs(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.create_extra_specs", self.proxy.create_flavor_extra_specs, method_args=["value", {'a': 'b'}], @@ -229,21 +229,21 @@ class TestFlavor(TestComputeProxy): expected_kwargs={"specs": {'a': 'b'}}) def test_get_flavor_extra_specs_prop(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.get_extra_specs_property", self.proxy.get_flavor_extra_specs_property, method_args=["value", "prop"], expected_args=[self.proxy, "prop"]) def test_update_flavor_extra_specs_prop(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.update_extra_specs_property", self.proxy.update_flavor_extra_specs_property, method_args=["value", "prop", "val"], expected_args=[self.proxy, "prop", "val"]) def test_delete_flavor_extra_specs_prop(self): - self._verify2( + self._verify( "openstack.compute.v2.flavor.Flavor.delete_extra_specs_property", self.proxy.delete_flavor_extra_specs_property, method_args=["value", "prop"], @@ -324,35 +324,35 @@ class TestAggregate(TestComputeProxy): self.verify_update(self.proxy.update_aggregate, aggregate.Aggregate) def test_aggregate_add_host(self): - self._verify2( + self._verify( "openstack.compute.v2.aggregate.Aggregate.add_host", self.proxy.add_host_to_aggregate, method_args=["value", "host"], expected_args=[self.proxy, "host"]) def test_aggregate_remove_host(self): - self._verify2( + self._verify( "openstack.compute.v2.aggregate.Aggregate.remove_host", self.proxy.remove_host_from_aggregate, method_args=["value", "host"], expected_args=[self.proxy, "host"]) def test_aggregate_set_metadata(self): - self._verify2( + self._verify( "openstack.compute.v2.aggregate.Aggregate.set_metadata", self.proxy.set_aggregate_metadata, method_args=["value", {'a': 'b'}], expected_args=[self.proxy, {'a': 'b'}]) def test_aggregate_precache_image(self): - self._verify2( + self._verify( "openstack.compute.v2.aggregate.Aggregate.precache_images", self.proxy.aggregate_precache_images, method_args=["value", '1'], expected_args=[self.proxy, [{'id': '1'}]]) def test_aggregate_precache_images(self): - self._verify2( + self._verify( "openstack.compute.v2.aggregate.Aggregate.precache_images", self.proxy.aggregate_precache_images, method_args=["value", ['1', '2']], @@ -366,7 +366,7 @@ class TestService(TestComputeProxy): @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=False) def test_enable_service_252(self, mv_mock): - self._verify2( + self._verify( 'openstack.compute.v2.service.Service.enable', self.proxy.enable_service, method_args=["value", "host1", "nova-compute"], @@ -376,7 +376,7 @@ class TestService(TestComputeProxy): @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=True) def test_enable_service_253(self, mv_mock): - self._verify2( + self._verify( 'openstack.proxy.Proxy._update', self.proxy.enable_service, method_args=["value"], @@ -388,7 +388,7 @@ class TestService(TestComputeProxy): @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=False) def test_disable_service_252(self, mv_mock): - self._verify2( + self._verify( 'openstack.compute.v2.service.Service.disable', self.proxy.disable_service, method_args=["value", "host1", "nova-compute"], @@ -397,7 +397,7 @@ class TestService(TestComputeProxy): @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=True) def test_disable_service_253(self, mv_mock): - self._verify2( + self._verify( 'openstack.proxy.Proxy._update', self.proxy.disable_service, method_args=["value"], @@ -412,7 +412,7 @@ class TestService(TestComputeProxy): @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=False) def test_force_service_down_252(self, mv_mock): - self._verify2( + self._verify( 'openstack.compute.v2.service.Service.set_forced_down', self.proxy.update_service_forced_down, method_args=["value", "host1", "nova-compute"], @@ -430,7 +430,7 @@ class TestService(TestComputeProxy): @mock.patch('openstack.utils.supports_microversion', autospec=True, return_value=False) def test_force_service_down_252_empty_vals_svc(self, mv_mock): - self._verify2( + self._verify( 'openstack.compute.v2.service.Service.set_forced_down', self.proxy.update_service_forced_down, method_args=[{'host': 'a', 'binary': 'b'}, None, None], @@ -516,7 +516,7 @@ class TestHypervisor(TestComputeProxy): hypervisor.Hypervisor) def test_get_hypervisor_uptime(self): - self._verify2( + self._verify( "openstack.compute.v2.hypervisor.Hypervisor.get_uptime", self.proxy.get_hypervisor_uptime, method_args=["value"], @@ -570,24 +570,22 @@ class TestCompute(TestComputeProxy): test_interface.server_id = server_id # Case1: ServerInterface instance is provided as value - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_server_interface, - method_args=[test_interface], - method_kwargs={"server": server_id}, - expected_args=[ - server_interface.ServerInterface, interface_id], - expected_kwargs={"server_id": server_id, - "ignore_missing": True}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_server_interface, + method_args=[test_interface], + method_kwargs={"server": server_id}, + expected_args=[server_interface.ServerInterface, interface_id], + expected_kwargs={"server_id": server_id, "ignore_missing": True}) # Case2: ServerInterface ID is provided as value - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_server_interface, - method_args=[interface_id], - method_kwargs={"server": server_id}, - expected_args=[ - server_interface.ServerInterface, interface_id], - expected_kwargs={"server_id": server_id, - "ignore_missing": True}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_server_interface, + method_args=[interface_id], + method_kwargs={"server": server_id}, + expected_args=[server_interface.ServerInterface, interface_id], + expected_kwargs={"server_id": server_id, "ignore_missing": True}) def test_server_interface_delete_ignore(self): self.proxy._get_uri_attribute = lambda *args: args[1] @@ -606,22 +604,22 @@ class TestCompute(TestComputeProxy): test_interface.server_id = server_id # Case1: ServerInterface instance is provided as value - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_server_interface, - method_args=[test_interface], - method_kwargs={"server": server_id}, - expected_args=[server_interface.ServerInterface], - expected_kwargs={"port_id": interface_id, - "server_id": server_id}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_server_interface, + method_args=[test_interface], + method_kwargs={"server": server_id}, + expected_args=[server_interface.ServerInterface], + expected_kwargs={"port_id": interface_id, "server_id": server_id}) # Case2: ServerInterface ID is provided as value - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_server_interface, - method_args=[interface_id], - method_kwargs={"server": server_id}, - expected_args=[server_interface.ServerInterface], - expected_kwargs={"port_id": interface_id, - "server_id": server_id}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_server_interface, + method_args=[interface_id], + method_kwargs={"server": server_id}, + expected_args=[server_interface.ServerInterface], + expected_kwargs={"port_id": interface_id, "server_id": server_id}) def test_server_interfaces(self): self.verify_list(self.proxy.server_interfaces, @@ -655,7 +653,7 @@ class TestCompute(TestComputeProxy): self.verify_delete(self.proxy.delete_server, server.Server, True) def test_server_force_delete(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.force_delete", self.proxy.delete_server, method_args=["value", False, True], @@ -691,21 +689,21 @@ class TestCompute(TestComputeProxy): expected_args=[self.proxy, value, 'ACTIVE', ['ERROR'], 2, 120]) def test_server_resize(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.resize", self.proxy.resize_server, method_args=["value", "test-flavor"], expected_args=[self.proxy, "test-flavor"]) def test_server_confirm_resize(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.confirm_resize", self.proxy.confirm_server_resize, method_args=["value"], expected_args=[self.proxy]) def test_server_revert_resize(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.revert_resize", self.proxy.revert_server_resize, method_args=["value"], @@ -718,7 +716,7 @@ class TestCompute(TestComputeProxy): # Case1: image object is provided # NOTE: Inside of Server.rebuild is where image_obj gets converted # to an ID instead of object. - self._verify2( + self._verify( 'openstack.compute.v2.server.Server.rebuild', self.proxy.rebuild_server, method_args=["value", "test_server", "test_pass"], @@ -727,7 +725,7 @@ class TestCompute(TestComputeProxy): expected_kwargs={"metadata": {"k1": "v1"}, "image": image_obj}) # Case2: image name or id is provided - self._verify2( + self._verify( 'openstack.compute.v2.server.Server.rebuild', self.proxy.rebuild_server, method_args=["value", "test_server", "test_pass"], @@ -736,21 +734,21 @@ class TestCompute(TestComputeProxy): expected_kwargs={"metadata": {"k1": "v1"}, "image": id}) def test_add_fixed_ip_to_server(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.add_fixed_ip", self.proxy.add_fixed_ip_to_server, method_args=["value", "network-id"], expected_args=[self.proxy, "network-id"]) def test_fixed_ip_from_server(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.remove_fixed_ip", self.proxy.remove_fixed_ip_from_server, method_args=["value", "address"], expected_args=[self.proxy, "address"]) def test_floating_ip_to_server(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.add_floating_ip", self.proxy.add_floating_ip_to_server, method_args=["value", "floating-ip"], @@ -758,7 +756,7 @@ class TestCompute(TestComputeProxy): expected_kwargs={'fixed_address': None}) def test_add_floating_ip_to_server_with_fixed_addr(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.add_floating_ip", self.proxy.add_floating_ip_to_server, method_args=["value", "floating-ip", 'fixed-addr'], @@ -766,63 +764,63 @@ class TestCompute(TestComputeProxy): expected_kwargs={'fixed_address': 'fixed-addr'}) def test_remove_floating_ip_from_server(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.remove_floating_ip", self.proxy.remove_floating_ip_from_server, method_args=["value", "address"], expected_args=[self.proxy, "address"]) def test_server_backup(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.backup", self.proxy.backup_server, method_args=["value", "name", "daily", 1], expected_args=[self.proxy, "name", "daily", 1]) def test_server_pause(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.pause", self.proxy.pause_server, method_args=["value"], expected_args=[self.proxy]) def test_server_unpause(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.unpause", self.proxy.unpause_server, method_args=["value"], expected_args=[self.proxy]) def test_server_suspend(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.suspend", self.proxy.suspend_server, method_args=["value"], expected_args=[self.proxy]) def test_server_resume(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.resume", self.proxy.resume_server, method_args=["value"], expected_args=[self.proxy]) def test_server_lock(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.lock", self.proxy.lock_server, method_args=["value"], expected_args=[self.proxy]) def test_server_unlock(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.unlock", self.proxy.unlock_server, method_args=["value"], expected_args=[self.proxy]) def test_server_rescue(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.rescue", self.proxy.rescue_server, method_args=["value"], @@ -830,7 +828,7 @@ class TestCompute(TestComputeProxy): expected_kwargs={"admin_pass": None, "image_ref": None}) def test_server_rescue_with_options(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.rescue", self.proxy.rescue_server, method_args=["value", 'PASS', 'IMG'], @@ -838,14 +836,14 @@ class TestCompute(TestComputeProxy): expected_kwargs={"admin_pass": 'PASS', "image_ref": 'IMG'}) def test_server_unrescue(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.unrescue", self.proxy.unrescue_server, method_args=["value"], expected_args=[self.proxy]) def test_server_evacuate(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.evacuate", self.proxy.evacuate_server, method_args=["value"], @@ -853,7 +851,7 @@ class TestCompute(TestComputeProxy): expected_kwargs={"host": None, "admin_pass": None, "force": None}) def test_server_evacuate_with_options(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.evacuate", self.proxy.evacuate_server, method_args=["value", 'HOST2', 'NEW_PASS', True], @@ -862,42 +860,42 @@ class TestCompute(TestComputeProxy): "host": "HOST2", "admin_pass": 'NEW_PASS', "force": True}) def test_server_start(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.start", self.proxy.start_server, method_args=["value"], expected_args=[self.proxy]) def test_server_stop(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.stop", self.proxy.stop_server, method_args=["value"], expected_args=[self.proxy]) def test_server_shelve(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.shelve", self.proxy.shelve_server, method_args=["value"], expected_args=[self.proxy]) def test_server_unshelve(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.unshelve", self.proxy.unshelve_server, method_args=["value"], expected_args=[self.proxy]) def test_get_server_output(self): - self._verify2( + self._verify( "openstack.compute.v2.server.Server.get_console_output", self.proxy.get_server_console_output, method_args=["value"], expected_args=[self.proxy], expected_kwargs={"length": None}) - self._verify2( + self._verify( "openstack.compute.v2.server.Server.get_console_output", self.proxy.get_server_console_output, method_args=["value", 1], @@ -917,32 +915,34 @@ class TestCompute(TestComputeProxy): expected_kwargs={}) def test_get_all_server_metadata(self): - self._verify2("openstack.compute.v2.server.Server.get_metadata", - self.proxy.get_server_metadata, - method_args=["value"], - method_result=server.Server(id="value", metadata={}), - expected_args=[self.proxy], - expected_result={}) + self._verify( + "openstack.compute.v2.server.Server.get_metadata", + self.proxy.get_server_metadata, + method_args=["value"], + method_result=server.Server(id="value", metadata={}), + expected_args=[self.proxy], + expected_result={}) def test_set_server_metadata(self): kwargs = {"a": "1", "b": "2"} id = "an_id" - self._verify2("openstack.compute.v2.server.Server.set_metadata", - self.proxy.set_server_metadata, - method_args=[id], - method_kwargs=kwargs, - method_result=server.Server.existing(id=id, - metadata=kwargs), - expected_args=[self.proxy], - expected_kwargs=kwargs, - expected_result=kwargs) + self._verify( + "openstack.compute.v2.server.Server.set_metadata", + self.proxy.set_server_metadata, + method_args=[id], + method_kwargs=kwargs, + method_result=server.Server.existing(id=id, metadata=kwargs), + expected_args=[self.proxy], + expected_kwargs=kwargs, + expected_result=kwargs) def test_delete_server_metadata(self): - self._verify2("openstack.compute.v2.server.Server.delete_metadata", - self.proxy.delete_server_metadata, - expected_result=None, - method_args=["value", "key"], - expected_args=[self.proxy, "key"]) + self._verify( + "openstack.compute.v2.server.Server.delete_metadata", + self.proxy.delete_server_metadata, + expected_result=None, + method_args=["value", "key"], + expected_args=[self.proxy, "key"]) def test_create_image(self): metadata = {'k1': 'v1'} @@ -995,7 +995,7 @@ class TestCompute(TestComputeProxy): self.verify_list(self.proxy.server_groups, server_group.ServerGroup) def test_live_migrate_server(self): - self._verify2( + self._verify( 'openstack.compute.v2.server.Server.live_migrate', self.proxy.live_migrate_server, method_args=["value", "host1", False], @@ -1003,21 +1003,21 @@ class TestCompute(TestComputeProxy): expected_kwargs={'force': False, 'block_migration': None}) def test_fetch_security_groups(self): - self._verify2( + self._verify( 'openstack.compute.v2.server.Server.fetch_security_groups', self.proxy.fetch_server_security_groups, method_args=["value"], expected_args=[self.proxy]) def test_add_security_groups(self): - self._verify2( + self._verify( 'openstack.compute.v2.server.Server.add_security_group', self.proxy.add_security_group_to_server, method_args=["value", {'id': 'id', 'name': 'sg'}], expected_args=[self.proxy, 'sg']) def test_remove_security_groups(self): - self._verify2( + self._verify( 'openstack.compute.v2.server.Server.remove_security_group', self.proxy.remove_security_group_from_server, method_args=["value", {'id': 'id', 'name': 'sg'}], @@ -1031,7 +1031,7 @@ class TestCompute(TestComputeProxy): expected_kwargs={"server_id": "test_id", "type": "fake"}) def test_get_console_url(self): - self._verify2( + self._verify( 'openstack.compute.v2.server.Server.get_console_url', self.proxy.get_server_console_url, method_args=["value", "console_type"], diff --git a/openstack/tests/unit/database/v1/test_proxy.py b/openstack/tests/unit/database/v1/test_proxy.py index 017810f06..81f276dd8 100644 --- a/openstack/tests/unit/database/v1/test_proxy.py +++ b/openstack/tests/unit/database/v1/test_proxy.py @@ -44,12 +44,13 @@ class TestDatabaseProxy(test_proxy_base.TestProxyBase): expected_kwargs={"instance_id": "test_id"}) def test_database_find(self): - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_database, - method_args=["db", "instance"], - expected_args=[database.Database, "db"], - expected_kwargs={"instance_id": "instance", - "ignore_missing": True}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_database, + method_args=["db", "instance"], + expected_args=[database.Database, "db"], + expected_kwargs={ + "instance_id": "instance", "ignore_missing": True}) def test_databases(self): self.verify_list(self.proxy.databases, database.Database, @@ -108,12 +109,13 @@ class TestDatabaseProxy(test_proxy_base.TestProxyBase): expected_kwargs={"instance_id": "id"}) def test_user_find(self): - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_user, - method_args=["user", "instance"], - expected_args=[user.User, "user"], - expected_kwargs={"instance_id": "instance", - "ignore_missing": True}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_user, + method_args=["user", "instance"], + expected_args=[user.User, "user"], + expected_kwargs={ + "instance_id": "instance", "ignore_missing": True}) def test_users(self): self.verify_list(self.proxy.users, user.User, diff --git a/openstack/tests/unit/dns/v2/test_proxy.py b/openstack/tests/unit/dns/v2/test_proxy.py index 48369b8f3..d628a724b 100644 --- a/openstack/tests/unit/dns/v2/test_proxy.py +++ b/openstack/tests/unit/dns/v2/test_proxy.py @@ -50,16 +50,18 @@ class TestDnsZone(TestDnsProxy): self.verify_update(self.proxy.update_zone, zone.Zone) def test_zone_abandon(self): - self._verify2("openstack.dns.v2.zone.Zone.abandon", - self.proxy.abandon_zone, - method_args=[{'zone': 'id'}], - expected_args=[self.proxy]) + self._verify( + "openstack.dns.v2.zone.Zone.abandon", + self.proxy.abandon_zone, + method_args=[{'zone': 'id'}], + expected_args=[self.proxy]) def test_zone_xfr(self): - self._verify2("openstack.dns.v2.zone.Zone.xfr", - self.proxy.xfr_zone, - method_args=[{'zone': 'id'}], - expected_args=[self.proxy]) + self._verify( + "openstack.dns.v2.zone.Zone.xfr", + self.proxy.xfr_zone, + method_args=[{'zone': 'id'}], + expected_args=[self.proxy]) class TestDnsRecordset(TestDnsProxy): @@ -92,13 +94,13 @@ class TestDnsRecordset(TestDnsProxy): expected_kwargs={'zone_id': 'zid'}) def test_recordset_find(self): - self._verify2("openstack.proxy.Proxy._find", - self.proxy.find_recordset, - method_args=['zone', 'rs'], - method_kwargs={}, - expected_args=[recordset.Recordset, 'rs'], - expected_kwargs={'ignore_missing': True, - 'zone_id': 'zone'}) + self._verify( + "openstack.proxy.Proxy._find", + self.proxy.find_recordset, + method_args=['zone', 'rs'], + method_kwargs={}, + expected_args=[recordset.Recordset, 'rs'], + expected_kwargs={'ignore_missing': True, 'zone_id': 'zone'}) class TestDnsFloatIP(TestDnsProxy): diff --git a/openstack/tests/unit/image/v2/test_proxy.py b/openstack/tests/unit/image/v2/test_proxy.py index 715d4b2a1..0a2826872 100644 --- a/openstack/tests/unit/image/v2/test_proxy.py +++ b/openstack/tests/unit/image/v2/test_proxy.py @@ -54,7 +54,7 @@ class TestImageProxy(test_proxy_base.TestProxyBase): def test_image_import(self): original_image = image.Image(**EXAMPLE) - self._verify2( + self._verify( "openstack.image.v2.image.Image.import_image", self.proxy.import_image, method_args=[original_image, "method", "uri"], @@ -219,7 +219,7 @@ class TestImageProxy(test_proxy_base.TestProxyBase): def test_image_download(self): original_image = image.Image(**EXAMPLE) - self._verify2( + self._verify( 'openstack.image.v2.image.Image.download', self.proxy.download_image, method_args=[original_image], @@ -294,28 +294,28 @@ class TestImageProxy(test_proxy_base.TestProxyBase): self.verify_list(self.proxy.images, image.Image) def test_add_tag(self): - self._verify2( + self._verify( "openstack.image.v2.image.Image.add_tag", self.proxy.add_tag, method_args=["image", "tag"], expected_args=[self.proxy, "tag"]) def test_remove_tag(self): - self._verify2( + self._verify( "openstack.image.v2.image.Image.remove_tag", self.proxy.remove_tag, method_args=["image", "tag"], expected_args=[self.proxy, "tag"]) def test_deactivate_image(self): - self._verify2( + self._verify( "openstack.image.v2.image.Image.deactivate", self.proxy.deactivate_image, method_args=["image"], expected_args=[self.proxy]) def test_reactivate_image(self): - self._verify2( + self._verify( "openstack.image.v2.image.Image.reactivate", self.proxy.reactivate_image, method_args=["image"], @@ -327,51 +327,54 @@ class TestImageProxy(test_proxy_base.TestProxyBase): expected_kwargs={"image_id": "test_id"}) def test_member_delete(self): - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.remove_member, - method_args=["member_id"], - method_kwargs={"image": "image_id", - "ignore_missing": False}, - expected_args=[member.Member], - expected_kwargs={"member_id": "member_id", - "image_id": "image_id", - "ignore_missing": False}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.remove_member, + method_args=["member_id"], + method_kwargs={"image": "image_id", "ignore_missing": False}, + expected_args=[member.Member], + expected_kwargs={ + "member_id": "member_id", + "image_id": "image_id", + "ignore_missing": False}) def test_member_delete_ignore(self): - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.remove_member, - method_args=["member_id"], - method_kwargs={"image": "image_id"}, - expected_args=[member.Member], - expected_kwargs={"member_id": "member_id", - "image_id": "image_id", - "ignore_missing": True}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.remove_member, + method_args=["member_id"], + method_kwargs={"image": "image_id"}, + expected_args=[member.Member], + expected_kwargs={ + "member_id": "member_id", + "image_id": "image_id", + "ignore_missing": True}) def test_member_update(self): - self._verify2("openstack.proxy.Proxy._update", - self.proxy.update_member, - method_args=['member_id', 'image_id'], - expected_args=[member.Member], - expected_kwargs={'member_id': 'member_id', - 'image_id': 'image_id'}) + self._verify( + "openstack.proxy.Proxy._update", + self.proxy.update_member, + method_args=['member_id', 'image_id'], + expected_args=[member.Member], + expected_kwargs={'member_id': 'member_id', 'image_id': 'image_id'}) def test_member_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_member, - method_args=['member_id'], - method_kwargs={"image": "image_id"}, - expected_args=[member.Member], - expected_kwargs={'member_id': 'member_id', - 'image_id': 'image_id'}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_member, + method_args=['member_id'], + method_kwargs={"image": "image_id"}, + expected_args=[member.Member], + expected_kwargs={'member_id': 'member_id', 'image_id': 'image_id'}) def test_member_find(self): - self._verify2("openstack.proxy.Proxy._find", - self.proxy.find_member, - method_args=['member_id'], - method_kwargs={"image": "image_id"}, - expected_args=[member.Member, "member_id"], - expected_kwargs={'ignore_missing': True, - 'image_id': 'image_id'}) + self._verify( + "openstack.proxy.Proxy._find", + self.proxy.find_member, + method_args=['member_id'], + method_kwargs={"image": "image_id"}, + expected_args=[member.Member, "member_id"], + expected_kwargs={'ignore_missing': True, 'image_id': 'image_id'}) def test_members(self): self.verify_list(self.proxy.members, member.Member, @@ -379,32 +382,36 @@ class TestImageProxy(test_proxy_base.TestProxyBase): expected_kwargs={'image_id': 'image_1'}) def test_images_schema_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_images_schema, - expected_args=[schema.Schema], - expected_kwargs={'base_path': '/schemas/images', - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_images_schema, + expected_args=[schema.Schema], + expected_kwargs={ + 'base_path': '/schemas/images', 'requires_id': False}) def test_image_schema_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_image_schema, - expected_args=[schema.Schema], - expected_kwargs={'base_path': '/schemas/image', - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_image_schema, + expected_args=[schema.Schema], + expected_kwargs={ + 'base_path': '/schemas/image', 'requires_id': False}) def test_members_schema_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_members_schema, - expected_args=[schema.Schema], - expected_kwargs={'base_path': '/schemas/members', - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_members_schema, + expected_args=[schema.Schema], + expected_kwargs={ + 'base_path': '/schemas/members', 'requires_id': False}) def test_member_schema_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_member_schema, - expected_args=[schema.Schema], - expected_kwargs={'base_path': '/schemas/member', - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_member_schema, + expected_args=[schema.Schema], + expected_kwargs={ + 'base_path': '/schemas/member', 'requires_id': False}) def test_task_get(self): self.verify_get(self.proxy.get_task, task.Task) @@ -488,26 +495,29 @@ class TestImageProxy(test_proxy_base.TestProxyBase): self.assertEqual('success', result.status) def test_tasks_schema_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_tasks_schema, - expected_args=[schema.Schema], - expected_kwargs={'base_path': '/schemas/tasks', - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_tasks_schema, + expected_args=[schema.Schema], + expected_kwargs={ + 'base_path': '/schemas/tasks', 'requires_id': False}) def test_task_schema_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_task_schema, - expected_args=[schema.Schema], - expected_kwargs={'base_path': '/schemas/task', - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_task_schema, + expected_args=[schema.Schema], + expected_kwargs={ + 'base_path': '/schemas/task', 'requires_id': False}) def test_stores(self): self.verify_list(self.proxy.stores, si.Store) def test_import_info(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_import_info, - method_args=[], - method_kwargs={}, - expected_args=[si.Import], - expected_kwargs={'require_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_import_info, + method_args=[], + method_kwargs={}, + expected_args=[si.Import], + expected_kwargs={'require_id': False}) diff --git a/openstack/tests/unit/load_balancer/v2/test_proxy.py b/openstack/tests/unit/load_balancer/v2/test_proxy.py index 0983845aa..c045826e9 100644 --- a/openstack/tests/unit/load_balancer/v2/test_proxy.py +++ b/openstack/tests/unit/load_balancer/v2/test_proxy.py @@ -70,13 +70,12 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): fake_load_balancer = mock.Mock() fake_load_balancer.id = "load_balancer_id" mock_get_resource.return_value = fake_load_balancer - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_load_balancer, - method_args=["resource_or_id", True, - False], - expected_args=[lb.LoadBalancer, - fake_load_balancer], - expected_kwargs={"ignore_missing": True}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_load_balancer, + method_args=["resource_or_id", True, False], + expected_args=[lb.LoadBalancer, fake_load_balancer], + expected_kwargs={"ignore_missing": True}) self.assertFalse(fake_load_balancer.cascade) mock_get_resource.assert_called_once_with(lb.LoadBalancer, "resource_or_id") @@ -86,13 +85,12 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): fake_load_balancer = mock.Mock() fake_load_balancer.id = "load_balancer_id" mock_get_resource.return_value = fake_load_balancer - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_load_balancer, - method_args=["resource_or_id", True, - True], - expected_args=[lb.LoadBalancer, - fake_load_balancer], - expected_kwargs={"ignore_missing": True}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_load_balancer, + method_args=["resource_or_id", True, True], + expected_args=[lb.LoadBalancer, fake_load_balancer], + expected_kwargs={"ignore_missing": True}) self.assertTrue(fake_load_balancer.cascade) mock_get_resource.assert_called_once_with(lb.LoadBalancer, "resource_or_id") @@ -196,19 +194,20 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): 'ignore_missing': True}) def test_member_find(self): - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_member, - method_args=["MEMBER", self.POOL_ID], - expected_args=[member.Member, "MEMBER"], - expected_kwargs={"pool_id": self.POOL_ID, - "ignore_missing": True}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_member, + method_args=["MEMBER", self.POOL_ID], + expected_args=[member.Member, "MEMBER"], + expected_kwargs={"pool_id": self.POOL_ID, "ignore_missing": True}) def test_member_update(self): - self._verify2('openstack.proxy.Proxy._update', - self.proxy.update_member, - method_args=["MEMBER", self.POOL_ID], - expected_args=[member.Member, "MEMBER"], - expected_kwargs={"pool_id": self.POOL_ID}) + self._verify( + 'openstack.proxy.Proxy._update', + self.proxy.update_member, + method_args=["MEMBER", self.POOL_ID], + expected_args=[member.Member, "MEMBER"], + expected_kwargs={"pool_id": self.POOL_ID}) def test_health_monitors(self): self.verify_list(self.proxy.health_monitors, @@ -284,19 +283,21 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): expected_kwargs={'l7policy_id': self.L7_POLICY_ID}) def test_l7_rule_find(self): - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_l7_rule, - method_args=["RULE", self.L7_POLICY_ID], - expected_args=[l7_rule.L7Rule, "RULE"], - expected_kwargs={"l7policy_id": self.L7_POLICY_ID, - "ignore_missing": True}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_l7_rule, + method_args=["RULE", self.L7_POLICY_ID], + expected_args=[l7_rule.L7Rule, "RULE"], + expected_kwargs={ + "l7policy_id": self.L7_POLICY_ID, "ignore_missing": True}) def test_l7_rule_update(self): - self._verify2('openstack.proxy.Proxy._update', - self.proxy.update_l7_rule, - method_args=["RULE", self.L7_POLICY_ID], - expected_args=[l7_rule.L7Rule, "RULE"], - expected_kwargs={"l7policy_id": self.L7_POLICY_ID}) + self._verify( + 'openstack.proxy.Proxy._update', + self.proxy.update_l7_rule, + method_args=["RULE", self.L7_POLICY_ID], + expected_args=[l7_rule.L7Rule, "RULE"], + expected_kwargs={"l7policy_id": self.L7_POLICY_ID}) def test_quotas(self): self.verify_list(self.proxy.quotas, quota.Quota) @@ -308,10 +309,11 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): self.verify_update(self.proxy.update_quota, quota.Quota) def test_quota_default_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_quota_default, - expected_args=[quota.QuotaDefault], - expected_kwargs={'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_quota_default, + expected_args=[quota.QuotaDefault], + expected_kwargs={'requires_id': False}) def test_quota_delete(self): self.verify_delete(self.proxy.delete_quota, quota.Quota, False) diff --git a/openstack/tests/unit/message/v2/test_proxy.py b/openstack/tests/unit/message/v2/test_proxy.py index 540b91359..fa3baf991 100644 --- a/openstack/tests/unit/message/v2/test_proxy.py +++ b/openstack/tests/unit/message/v2/test_proxy.py @@ -50,7 +50,7 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): def test_message_post(self, mock_get_resource): message_obj = message.Message(queue_name="test_queue") mock_get_resource.return_value = message_obj - self._verify2( + self._verify( "openstack.message.v2.message.Message.post", self.proxy.post_message, method_args=["test_queue", ["msg1", "msg2"]], @@ -61,10 +61,11 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_message_get(self, mock_get_resource): mock_get_resource.return_value = "resource_or_id" - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_message, - method_args=["test_queue", "resource_or_id"], - expected_args=[message.Message, "resource_or_id"]) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_message, + method_args=["test_queue", "resource_or_id"], + expected_args=[message.Message, "resource_or_id"]) mock_get_resource.assert_called_once_with(message.Message, "resource_or_id", queue_name="test_queue") @@ -82,13 +83,12 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): fake_message = mock.Mock() fake_message.id = "message_id" mock_get_resource.return_value = fake_message - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_message, - method_args=["test_queue", "resource_or_id", None, - False], - expected_args=[message.Message, - fake_message], - expected_kwargs={"ignore_missing": False}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_message, + method_args=["test_queue", "resource_or_id", None, False], + expected_args=[message.Message, fake_message], + expected_kwargs={"ignore_missing": False}) self.assertIsNone(fake_message.claim_id) mock_get_resource.assert_called_once_with(message.Message, "resource_or_id", @@ -99,13 +99,12 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): fake_message = mock.Mock() fake_message.id = "message_id" mock_get_resource.return_value = fake_message - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_message, - method_args=["test_queue", "resource_or_id", "claim_id", - False], - expected_args=[message.Message, - fake_message], - expected_kwargs={"ignore_missing": False}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_message, + method_args=["test_queue", "resource_or_id", "claim_id", False], + expected_args=[message.Message, fake_message], + expected_kwargs={"ignore_missing": False}) self.assertEqual("claim_id", fake_message.claim_id) mock_get_resource.assert_called_once_with(message.Message, "resource_or_id", @@ -116,20 +115,19 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): fake_message = mock.Mock() fake_message.id = "message_id" mock_get_resource.return_value = fake_message - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_message, - method_args=["test_queue", "resource_or_id", None, - True], - expected_args=[message.Message, - fake_message], - expected_kwargs={"ignore_missing": True}) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_message, + method_args=["test_queue", "resource_or_id", None, True], + expected_args=[message.Message, fake_message], + expected_kwargs={"ignore_missing": True}) self.assertIsNone(fake_message.claim_id) mock_get_resource.assert_called_once_with(message.Message, "resource_or_id", queue_name="test_queue") def test_subscription_create(self): - self._verify2( + self._verify( "openstack.message.v2.subscription.Subscription.create", self.proxy.create_subscription, method_args=["test_queue"], @@ -139,11 +137,11 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): @mock.patch.object(proxy_base.Proxy, '_get_resource') def test_subscription_get(self, mock_get_resource): mock_get_resource.return_value = "resource_or_id" - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_subscription, - method_args=["test_queue", "resource_or_id"], - expected_args=[subscription.Subscription, - "resource_or_id"]) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_subscription, + method_args=["test_queue", "resource_or_id"], + expected_args=[subscription.Subscription, "resource_or_id"]) mock_get_resource.assert_called_once_with( subscription.Subscription, "resource_or_id", queue_name="test_queue") @@ -181,7 +179,7 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): queue_name="test_queue") def test_claim_create(self): - self._verify2( + self._verify( "openstack.message.v2.claim.Claim.create", self.proxy.create_claim, method_args=["test_queue"], @@ -189,25 +187,24 @@ class TestMessageProxy(test_proxy_base.TestProxyBase): expected_kwargs={"base_path": None}) def test_claim_get(self): - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_claim, - method_args=["test_queue", "resource_or_id"], - expected_args=[claim.Claim, - "resource_or_id"], - expected_kwargs={"queue_name": "test_queue"}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_claim, + method_args=["test_queue", "resource_or_id"], + expected_args=[claim.Claim, "resource_or_id"], + expected_kwargs={"queue_name": "test_queue"}) self.verify_get_overrided( self.proxy, claim.Claim, 'openstack.message.v2.claim.Claim') def test_claim_update(self): - self._verify2("openstack.proxy.Proxy._update", - self.proxy.update_claim, - method_args=["test_queue", "resource_or_id"], - method_kwargs={"k1": "v1"}, - expected_args=[claim.Claim, - "resource_or_id"], - expected_kwargs={"queue_name": "test_queue", - "k1": "v1"}) + self._verify( + "openstack.proxy.Proxy._update", + self.proxy.update_claim, + method_args=["test_queue", "resource_or_id"], + method_kwargs={"k1": "v1"}, + expected_args=[claim.Claim, "resource_or_id"], + expected_kwargs={"queue_name": "test_queue", "k1": "v1"}) def test_claim_delete(self): self.verify_delete(self.proxy.delete_claim, diff --git a/openstack/tests/unit/network/v2/test_proxy.py b/openstack/tests/unit/network/v2/test_proxy.py index 00eddda0e..c8e873f63 100644 --- a/openstack/tests/unit/network/v2/test_proxy.py +++ b/openstack/tests/unit/network/v2/test_proxy.py @@ -366,13 +366,13 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.verify_find(self.proxy.find_network, network.Network) def test_network_find_with_filter(self): - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_network, - method_args=["net1"], - method_kwargs={"project_id": "1"}, - expected_args=[network.Network, "net1"], - expected_kwargs={"project_id": "1", - "ignore_missing": True}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_network, + method_args=["net1"], + method_kwargs={"project_id": "1"}, + expected_args=[network.Network, "net1"], + expected_kwargs={"project_id": "1", "ignore_missing": True}) def test_network_get(self): self.verify_get(self.proxy.get_network, network.Network) @@ -469,19 +469,20 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): expected_kwargs={"pool_id": "test_id"}) def test_pool_member_find(self): - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_pool_member, - method_args=["MEMBER", "POOL"], - expected_args=[pool_member.PoolMember, "MEMBER"], - expected_kwargs={"pool_id": "POOL", - "ignore_missing": True}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_pool_member, + method_args=["MEMBER", "POOL"], + expected_args=[pool_member.PoolMember, "MEMBER"], + expected_kwargs={"pool_id": "POOL", "ignore_missing": True}) def test_pool_member_get(self): - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_pool_member, - method_args=["MEMBER", "POOL"], - expected_args=[pool_member.PoolMember, "MEMBER"], - expected_kwargs={"pool_id": "POOL"}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_pool_member, + method_args=["MEMBER", "POOL"], + expected_args=[pool_member.PoolMember, "MEMBER"], + expected_kwargs={"pool_id": "POOL"}) def test_pool_members(self): self.verify_list( @@ -491,11 +492,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): expected_kwargs={"pool_id": "test_id"}) def test_pool_member_update(self): - self._verify2("openstack.network.v2._proxy.Proxy._update", - self.proxy.update_pool_member, - method_args=["MEMBER", "POOL"], - expected_args=[pool_member.PoolMember, "MEMBER"], - expected_kwargs={"pool_id": "POOL"}) + self._verify( + "openstack.network.v2._proxy.Proxy._update", + self.proxy.update_pool_member, + method_args=["MEMBER", "POOL"], + expected_args=[pool_member.PoolMember, "MEMBER"], + expected_kwargs={"pool_id": "POOL"}) def test_pool_create_attrs(self): self.verify_create(self.proxy.create_pool, pool.Pool) @@ -590,14 +592,15 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_qos_bandwidth_limit_rule_find(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_qos_bandwidth_limit_rule, - method_args=['rule_id', policy], - expected_args=[ - qos_bandwidth_limit_rule.QoSBandwidthLimitRule, - 'rule_id'], - expected_kwargs={'ignore_missing': True, - 'qos_policy_id': QOS_POLICY_ID}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_qos_bandwidth_limit_rule, + method_args=['rule_id', policy], + expected_args=[ + qos_bandwidth_limit_rule.QoSBandwidthLimitRule, + 'rule_id'], + expected_kwargs={ + 'ignore_missing': True, 'qos_policy_id': QOS_POLICY_ID}) def test_qos_bandwidth_limit_rule_get(self): self.verify_get( @@ -615,15 +618,15 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_qos_bandwidth_limit_rule_update(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) - self._verify2('openstack.network.v2._proxy.Proxy._update', - self.proxy.update_qos_bandwidth_limit_rule, - method_args=['rule_id', policy], - method_kwargs={'foo': 'bar'}, - expected_args=[ - qos_bandwidth_limit_rule.QoSBandwidthLimitRule, - 'rule_id'], - expected_kwargs={'qos_policy_id': QOS_POLICY_ID, - 'foo': 'bar'}) + self._verify( + 'openstack.network.v2._proxy.Proxy._update', + self.proxy.update_qos_bandwidth_limit_rule, + method_args=['rule_id', policy], + method_kwargs={'foo': 'bar'}, + expected_args=[ + qos_bandwidth_limit_rule.QoSBandwidthLimitRule, + 'rule_id'], + expected_kwargs={'qos_policy_id': QOS_POLICY_ID, 'foo': 'bar'}) def test_qos_dscp_marking_rule_create_attrs(self): self.verify_create( @@ -652,13 +655,14 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_qos_dscp_marking_rule_find(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_qos_dscp_marking_rule, - method_args=['rule_id', policy], - expected_args=[qos_dscp_marking_rule.QoSDSCPMarkingRule, - 'rule_id'], - expected_kwargs={'ignore_missing': True, - 'qos_policy_id': QOS_POLICY_ID}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_qos_dscp_marking_rule, + method_args=['rule_id', policy], + expected_args=[ + qos_dscp_marking_rule.QoSDSCPMarkingRule, 'rule_id'], + expected_kwargs={ + 'ignore_missing': True, 'qos_policy_id': QOS_POLICY_ID}) def test_qos_dscp_marking_rule_get(self): self.verify_get( @@ -676,15 +680,15 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_qos_dscp_marking_rule_update(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) - self._verify2('openstack.network.v2._proxy.Proxy._update', - self.proxy.update_qos_dscp_marking_rule, - method_args=['rule_id', policy], - method_kwargs={'foo': 'bar'}, - expected_args=[ - qos_dscp_marking_rule.QoSDSCPMarkingRule, - 'rule_id'], - expected_kwargs={'qos_policy_id': QOS_POLICY_ID, - 'foo': 'bar'}) + self._verify( + 'openstack.network.v2._proxy.Proxy._update', + self.proxy.update_qos_dscp_marking_rule, + method_args=['rule_id', policy], + method_kwargs={'foo': 'bar'}, + expected_args=[ + qos_dscp_marking_rule.QoSDSCPMarkingRule, + 'rule_id'], + expected_kwargs={'qos_policy_id': QOS_POLICY_ID, 'foo': 'bar'}) def test_qos_minimum_bandwidth_rule_create_attrs(self): self.verify_create( @@ -713,14 +717,15 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_qos_minimum_bandwidth_rule_find(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_qos_minimum_bandwidth_rule, - method_args=['rule_id', policy], - expected_args=[ - qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule, - 'rule_id'], - expected_kwargs={'ignore_missing': True, - 'qos_policy_id': QOS_POLICY_ID}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_qos_minimum_bandwidth_rule, + method_args=['rule_id', policy], + expected_args=[ + qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule, + 'rule_id'], + expected_kwargs={ + 'ignore_missing': True, 'qos_policy_id': QOS_POLICY_ID}) def test_qos_minimum_bandwidth_rule_get(self): self.verify_get( @@ -738,15 +743,16 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_qos_minimum_bandwidth_rule_update(self): policy = qos_policy.QoSPolicy.new(id=QOS_POLICY_ID) - self._verify2('openstack.network.v2._proxy.Proxy._update', - self.proxy.update_qos_minimum_bandwidth_rule, - method_args=['rule_id', policy], - method_kwargs={'foo': 'bar'}, - expected_args=[ - qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule, - 'rule_id'], - expected_kwargs={'qos_policy_id': QOS_POLICY_ID, - 'foo': 'bar'}) + self._verify( + 'openstack.network.v2._proxy.Proxy._update', + self.proxy.update_qos_minimum_bandwidth_rule, + method_args=['rule_id', policy], + method_kwargs={'foo': 'bar'}, + expected_args=[ + qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule, + 'rule_id'], + expected_kwargs={ + 'qos_policy_id': QOS_POLICY_ID, 'foo': 'bar'}) def test_qos_policy_create_attrs(self): self.verify_create(self.proxy.create_qos_policy, qos_policy.QoSPolicy) @@ -795,25 +801,27 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_quota_get_details(self, mock_get): fake_quota = mock.Mock(project_id='PROJECT') mock_get.return_value = fake_quota - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_quota, - method_args=['QUOTA_ID'], - method_kwargs={'details': True}, - expected_args=[quota.QuotaDetails], - expected_kwargs={'project': fake_quota.id, - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_quota, + method_args=['QUOTA_ID'], + method_kwargs={'details': True}, + expected_args=[quota.QuotaDetails], + expected_kwargs={ + 'project': fake_quota.id, 'requires_id': False}) mock_get.assert_called_once_with(quota.Quota, 'QUOTA_ID') @mock.patch.object(proxy_base.Proxy, "_get_resource") def test_quota_default_get(self, mock_get): fake_quota = mock.Mock(project_id='PROJECT') mock_get.return_value = fake_quota - self._verify2("openstack.proxy.Proxy._get", - self.proxy.get_quota_default, - method_args=['QUOTA_ID'], - expected_args=[quota.QuotaDefault], - expected_kwargs={'project': fake_quota.id, - 'requires_id': False}) + self._verify( + "openstack.proxy.Proxy._get", + self.proxy.get_quota_default, + method_args=['QUOTA_ID'], + expected_args=[quota.QuotaDefault], + expected_kwargs={ + 'project': fake_quota.id, 'requires_id': False}) mock_get.assert_called_once_with(quota.Quota, 'QUOTA_ID') def test_quotas(self): @@ -891,7 +899,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.add_interface", self.proxy.add_interface_to_router, method_args=["FAKE_ROUTER"], @@ -907,7 +915,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.add_interface", self.proxy.add_interface_to_router, method_args=["FAKE_ROUTER"], @@ -923,7 +931,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.remove_interface", self.proxy.remove_interface_from_router, method_args=["FAKE_ROUTER"], @@ -939,7 +947,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.remove_interface", self.proxy.remove_interface_from_router, method_args=["FAKE_ROUTER"], @@ -955,7 +963,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.add_extra_routes", self.proxy.add_extra_routes_to_router, method_args=["FAKE_ROUTER"], @@ -971,7 +979,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.remove_extra_routes", self.proxy.remove_extra_routes_from_router, method_args=["FAKE_ROUTER"], @@ -986,7 +994,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.add_gateway", self.proxy.add_gateway_to_router, method_args=["FAKE_ROUTER"], @@ -1001,7 +1009,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): x_router = router.Router.new(id="ROUTER_ID") mock_get.return_value = x_router - self._verify2( + self._verify( "openstack.network.v2.router.Router.remove_gateway", self.proxy.remove_gateway_from_router, method_args=["FAKE_ROUTER"], @@ -1357,7 +1365,7 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_set_tags(self): x_network = network.Network.new(id='NETWORK_ID') - self._verify2( + self._verify( 'openstack.network.v2.network.Network.set_tags', self.proxy.set_tags, method_args=[x_network, ['TAG1', 'TAG2']], @@ -1398,24 +1406,26 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_find_floating_ip_port_forwarding(self): fip = floating_ip.FloatingIP.new(id=FIP_ID) - self._verify2('openstack.proxy.Proxy._find', - self.proxy.find_floating_ip_port_forwarding, - method_args=[fip, 'port_forwarding_id'], - expected_args=[ - port_forwarding.PortForwarding, - 'port_forwarding_id'], - expected_kwargs={'ignore_missing': True, - 'floatingip_id': FIP_ID}) + self._verify( + 'openstack.proxy.Proxy._find', + self.proxy.find_floating_ip_port_forwarding, + method_args=[fip, 'port_forwarding_id'], + expected_args=[ + port_forwarding.PortForwarding, + 'port_forwarding_id'], + expected_kwargs={ + 'ignore_missing': True, 'floatingip_id': FIP_ID}) def test_get_floating_ip_port_forwarding(self): fip = floating_ip.FloatingIP.new(id=FIP_ID) - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_floating_ip_port_forwarding, - method_args=[fip, 'port_forwarding_id'], - expected_args=[ - port_forwarding.PortForwarding, - 'port_forwarding_id'], - expected_kwargs={'floatingip_id': FIP_ID}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_floating_ip_port_forwarding, + method_args=[fip, 'port_forwarding_id'], + expected_args=[ + port_forwarding.PortForwarding, + 'port_forwarding_id'], + expected_kwargs={'floatingip_id': FIP_ID}) def test_floating_ip_port_forwardings(self): self.verify_list(self.proxy.floating_ip_port_forwardings, @@ -1425,15 +1435,15 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_update_floating_ip_port_forwarding(self): fip = floating_ip.FloatingIP.new(id=FIP_ID) - self._verify2('openstack.network.v2._proxy.Proxy._update', - self.proxy.update_floating_ip_port_forwarding, - method_args=[fip, 'port_forwarding_id'], - method_kwargs={'foo': 'bar'}, - expected_args=[ - port_forwarding.PortForwarding, - 'port_forwarding_id'], - expected_kwargs={'floatingip_id': FIP_ID, - 'foo': 'bar'}) + self._verify( + 'openstack.network.v2._proxy.Proxy._update', + self.proxy.update_floating_ip_port_forwarding, + method_args=[fip, 'port_forwarding_id'], + method_kwargs={'foo': 'bar'}, + expected_args=[ + port_forwarding.PortForwarding, + 'port_forwarding_id'], + expected_kwargs={'floatingip_id': FIP_ID, 'foo': 'bar'}) def test_create_l3_conntrack_helper(self): self.verify_create(self.proxy.create_conntrack_helper, @@ -1463,13 +1473,14 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_get_l3_conntrack_helper(self): r = router.Router.new(id=ROUTER_ID) - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_conntrack_helper, - method_args=['conntrack_helper_id', r], - expected_args=[ - l3_conntrack_helper.ConntrackHelper, - 'conntrack_helper_id'], - expected_kwargs={'router_id': ROUTER_ID}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_conntrack_helper, + method_args=['conntrack_helper_id', r], + expected_args=[ + l3_conntrack_helper.ConntrackHelper, + 'conntrack_helper_id'], + expected_kwargs={'router_id': ROUTER_ID}) def test_l3_conntrack_helpers(self): self.verify_list(self.proxy.conntrack_helpers, @@ -1480,12 +1491,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): def test_update_l3_conntrack_helper(self): r = router.Router.new(id=ROUTER_ID) - self._verify2('openstack.network.v2._proxy.Proxy._update', - self.proxy.update_conntrack_helper, - method_args=['conntrack_helper_id', r], - method_kwargs={'foo': 'bar'}, - expected_args=[ - l3_conntrack_helper.ConntrackHelper, - 'conntrack_helper_id'], - expected_kwargs={'router_id': ROUTER_ID, - 'foo': 'bar'}) + self._verify( + 'openstack.network.v2._proxy.Proxy._update', + self.proxy.update_conntrack_helper, + method_args=['conntrack_helper_id', r], + method_kwargs={'foo': 'bar'}, + expected_args=[ + l3_conntrack_helper.ConntrackHelper, + 'conntrack_helper_id'], + expected_kwargs={'router_id': ROUTER_ID, 'foo': 'bar'}) diff --git a/openstack/tests/unit/object_store/v1/test_proxy.py b/openstack/tests/unit/object_store/v1/test_proxy.py index e24c11542..81cf1f19c 100644 --- a/openstack/tests/unit/object_store/v1/test_proxy.py +++ b/openstack/tests/unit/object_store/v1/test_proxy.py @@ -64,12 +64,13 @@ class TestObjectStoreProxy(test_proxy_base.TestProxyBase): expected_kwargs={'name': 'container_name', "x": 1, "y": 2, "z": 3}) def test_object_metadata_get(self): - self._verify2("openstack.proxy.Proxy._head", - self.proxy.get_object_metadata, - method_args=['object'], - method_kwargs={'container': 'container'}, - expected_args=[obj.Object, 'object'], - expected_kwargs={'container': 'container'}) + self._verify( + "openstack.proxy.Proxy._head", + self.proxy.get_object_metadata, + method_args=['object'], + method_kwargs={'container': 'container'}, + expected_args=[obj.Object, 'object'], + expected_kwargs={'container': 'container'}) def _test_object_delete(self, ignore): expected_kwargs = { @@ -77,12 +78,13 @@ class TestObjectStoreProxy(test_proxy_base.TestProxyBase): "container": "name", } - self._verify2("openstack.proxy.Proxy._delete", - self.proxy.delete_object, - method_args=["resource"], - method_kwargs=expected_kwargs, - expected_args=[obj.Object, "resource"], - expected_kwargs=expected_kwargs) + self._verify( + "openstack.proxy.Proxy._delete", + self.proxy.delete_object, + method_args=["resource"], + method_kwargs=expected_kwargs, + expected_args=[obj.Object, "resource"], + expected_kwargs=expected_kwargs) def test_object_delete(self): self._test_object_delete(False) @@ -93,11 +95,12 @@ class TestObjectStoreProxy(test_proxy_base.TestProxyBase): def test_object_create_attrs(self): kwargs = {"name": "test", "data": "data", "container": "name"} - self._verify2("openstack.proxy.Proxy._create", - self.proxy.upload_object, - method_kwargs=kwargs, - expected_args=[obj.Object], - expected_kwargs=kwargs) + self._verify( + "openstack.proxy.Proxy._create", + self.proxy.upload_object, + method_kwargs=kwargs, + expected_args=[obj.Object], + expected_kwargs=kwargs) def test_object_create_no_container(self): self.assertRaises(TypeError, self.proxy.upload_object) diff --git a/openstack/tests/unit/orchestration/v1/test_proxy.py b/openstack/tests/unit/orchestration/v1/test_proxy.py index 32239e024..8c4943e87 100644 --- a/openstack/tests/unit/orchestration/v1/test_proxy.py +++ b/openstack/tests/unit/orchestration/v1/test_proxy.py @@ -51,23 +51,25 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): # 'ignore_missing': False # } # method_args=["name_or_id"] - # self._verify2(mock_method, test_method, - # method_args=method_args, - # method_kwargs=method_kwargs, - # expected_args=[stack.Stack, "name_or_id"], - # expected_kwargs=method_kwargs, - # expected_result="result") + # self._verify( + # mock_method, test_method, + # method_args=method_args, + # method_kwargs=method_kwargs, + # expected_args=[stack.Stack, "name_or_id"], + # expected_kwargs=method_kwargs, + # expected_result="result") # # method_kwargs = { # 'resolve_outputs': True, # 'ignore_missing': True # } - # self._verify2(mock_method, test_method, - # method_args=method_args, - # method_kwargs=method_kwargs, - # expected_args=[stack.Stack, "name_or_id"], - # expected_kwargs=method_kwargs, - # expected_result="result") + # self._verify( + # mock_method, test_method, + # method_args=method_args, + # method_kwargs=method_kwargs, + # expected_args=[stack.Stack, "name_or_id"], + # expected_kwargs=method_kwargs, + # expected_result="result") def test_stacks(self): self.verify_list(self.proxy.stacks, stack.Stack) @@ -81,27 +83,30 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): 'openstack.orchestration.v1.stack.Stack') def test_update_stack(self): - self._verify2('openstack.orchestration.v1.stack.Stack.update', - self.proxy.update_stack, - expected_result='result', - method_args=['stack'], - method_kwargs={'preview': False}, - expected_args=[self.proxy, False]) + self._verify( + 'openstack.orchestration.v1.stack.Stack.update', + self.proxy.update_stack, + expected_result='result', + method_args=['stack'], + method_kwargs={'preview': False}, + expected_args=[self.proxy, False]) def test_update_stack_preview(self): - self._verify2('openstack.orchestration.v1.stack.Stack.update', - self.proxy.update_stack, - expected_result='result', - method_args=['stack'], - method_kwargs={'preview': True}, - expected_args=[self.proxy, True]) + self._verify( + 'openstack.orchestration.v1.stack.Stack.update', + self.proxy.update_stack, + expected_result='result', + method_args=['stack'], + method_kwargs={'preview': True}, + expected_args=[self.proxy, True]) def test_abandon_stack(self): - self._verify2('openstack.orchestration.v1.stack.Stack.abandon', - self.proxy.abandon_stack, - expected_result='result', - method_args=['stack'], - expected_args=[self.proxy]) + self._verify( + 'openstack.orchestration.v1.stack.Stack.abandon', + self.proxy.abandon_stack, + expected_result='result', + method_args=['stack'], + expected_args=[self.proxy]) def test_delete_stack(self): self.verify_delete(self.proxy.delete_stack, stack.Stack, False) @@ -136,13 +141,15 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): stk = stack.Stack(id=stack_id, name=stack_name) mock_find.return_value = stk - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_stack_environment, - method_args=['IDENTITY'], - expected_args=[stack_environment.StackEnvironment], - expected_kwargs={'requires_id': False, - 'stack_name': stack_name, - 'stack_id': stack_id}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_stack_environment, + method_args=['IDENTITY'], + expected_args=[stack_environment.StackEnvironment], + expected_kwargs={ + 'requires_id': False, + 'stack_name': stack_name, + 'stack_id': stack_id}) mock_find.assert_called_once_with(mock.ANY, 'IDENTITY', ignore_missing=False) @@ -151,13 +158,15 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): stack_name = 'test_stack' stk = stack.Stack(id=stack_id, name=stack_name) - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_stack_environment, - method_args=[stk], - expected_args=[stack_environment.StackEnvironment], - expected_kwargs={'requires_id': False, - 'stack_name': stack_name, - 'stack_id': stack_id}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_stack_environment, + method_args=[stk], + expected_args=[stack_environment.StackEnvironment], + expected_kwargs={ + 'requires_id': False, + 'stack_name': stack_name, + 'stack_id': stack_id}) @mock.patch.object(stack_files.StackFiles, 'fetch') @mock.patch.object(stack.Stack, 'find') @@ -194,13 +203,15 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): stk = stack.Stack(id=stack_id, name=stack_name) mock_find.return_value = stk - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_stack_template, - method_args=['IDENTITY'], - expected_args=[stack_template.StackTemplate], - expected_kwargs={'requires_id': False, - 'stack_name': stack_name, - 'stack_id': stack_id}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_stack_template, + method_args=['IDENTITY'], + expected_args=[stack_template.StackTemplate], + expected_kwargs={ + 'requires_id': False, + 'stack_name': stack_name, + 'stack_id': stack_id}) mock_find.assert_called_once_with(mock.ANY, 'IDENTITY', ignore_missing=False) @@ -209,13 +220,15 @@ class TestOrchestrationProxy(test_proxy_base.TestProxyBase): stack_name = 'test_stack' stk = stack.Stack(id=stack_id, name=stack_name) - self._verify2('openstack.proxy.Proxy._get', - self.proxy.get_stack_template, - method_args=[stk], - expected_args=[stack_template.StackTemplate], - expected_kwargs={'requires_id': False, - 'stack_name': stack_name, - 'stack_id': stack_id}) + self._verify( + 'openstack.proxy.Proxy._get', + self.proxy.get_stack_template, + method_args=[stk], + expected_args=[stack_template.StackTemplate], + expected_kwargs={ + 'requires_id': False, + 'stack_name': stack_name, + 'stack_id': stack_id}) @mock.patch.object(stack.Stack, 'find') def test_resources_with_stack_object(self, mock_find): diff --git a/openstack/tests/unit/test_proxy_base.py b/openstack/tests/unit/test_proxy_base.py index b36fa4770..69a843807 100644 --- a/openstack/tests/unit/test_proxy_base.py +++ b/openstack/tests/unit/test_proxy_base.py @@ -20,39 +20,11 @@ class TestProxyBase(base.TestCase): super(TestProxyBase, self).setUp() self.session = mock.Mock() - def _verify(self, mock_method, test_method, - method_args=None, method_kwargs=None, - expected_args=None, expected_kwargs=None, - expected_result=None): - with mock.patch(mock_method) as mocked: - mocked.return_value = expected_result - if any([method_args, method_kwargs, - expected_args, expected_kwargs]): - method_args = method_args or () - method_kwargs = method_kwargs or {} - expected_args = expected_args or () - expected_kwargs = expected_kwargs or {} - - self.assertEqual(expected_result, test_method(*method_args, - **method_kwargs)) - mocked.assert_called_with(test_method.__self__, - *expected_args, **expected_kwargs) - else: - self.assertEqual(expected_result, test_method()) - mocked.assert_called_with(test_method.__self__) - - # NOTE(briancurtin): This is a duplicate version of _verify that is - # temporarily here while we shift APIs. The difference is that - # calls from the Proxy classes aren't going to be going directly into - # the Resource layer anymore, so they don't pass in the session which - # was tested in assert_called_with. - # This is being done in lieu of adding logic and complicating - # the _verify method. It will be removed once there is one API to - # be verifying. - def _verify2(self, mock_method, test_method, - method_args=None, method_kwargs=None, method_result=None, - expected_args=None, expected_kwargs=None, - expected_result=None): + def _verify( + self, mock_method, test_method, *, + method_args=None, method_kwargs=None, method_result=None, + expected_args=None, expected_kwargs=None, expected_result=None, + ): with mock.patch(mock_method) as mocked: mocked.return_value = expected_result if any([ @@ -120,7 +92,7 @@ class TestProxyBase(base.TestCase): expected_kwargs = method_kwargs.copy() expected_kwargs["base_path"] = base_path - self._verify2( + self._verify( mock_method, test_method, method_args=method_args, @@ -142,7 +114,7 @@ class TestProxyBase(base.TestCase): expected_args = expected_args or method_args.copy() expected_kwargs = expected_kwargs or method_kwargs.copy() - self._verify2( + self._verify( mock_method, test_method, method_args=method_args, @@ -166,7 +138,7 @@ class TestProxyBase(base.TestCase): if expected_kwargs is None: expected_kwargs = method_kwargs.copy() - self._verify2( + self._verify( mock_method, test_method, method_args=method_args, @@ -197,7 +169,7 @@ class TestProxyBase(base.TestCase): expected_args = expected_args or method_args.copy() expected_kwargs = expected_kwargs or method_kwargs.copy() - self._verify2( + self._verify( mock_method, test_method, method_args=method_args, @@ -219,7 +191,7 @@ class TestProxyBase(base.TestCase): expected_args = expected_args or method_args.copy() expected_kwargs = expected_kwargs or method_kwargs.copy() - self._verify2( + self._verify( mock_method, test_method, method_args=method_args, @@ -247,7 +219,7 @@ class TestProxyBase(base.TestCase): if base_path is not None: expected_kwargs["base_path"] = base_path - self._verify2( + self._verify( mock_method, test_method, method_args=method_args, @@ -272,7 +244,7 @@ class TestProxyBase(base.TestCase): if expected_kwargs is None: expected_kwargs = method_kwargs.copy() - self._verify2( + self._verify( mock_method, test_method, method_args=method_args, @@ -286,4 +258,4 @@ class TestProxyBase(base.TestCase): mock_method="openstack.resource.wait_for_status", **kwargs, ): - self._verify2(mock_method, test_method, **kwargs) + self._verify(mock_method, test_method, **kwargs)