python-openstackclient 6.1.0__py3-none-any.whl → 6.2.1__py3-none-any.whl

openstackclient/tests/unit/compute/v2/test_server_volume.py

@@ -11,11 +11,15 @@
 #   under the License.
 #
 
+from unittest import mock
+
 from novaclient import api_versions
+from openstack import utils as sdk_utils
 from osc_lib import exceptions
 
 from openstackclient.compute.v2 import server_volume
 from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes
+from openstackclient.tests.unit.volume.v2 import fakes as volume_fakes
 
 
 class TestServerVolume(compute_fakes.TestComputev2):
@@ -23,13 +27,11 @@ class TestServerVolume(compute_fakes.TestComputev2):
     def setUp(self):
         super().setUp()
 
-        # Get a shortcut to the compute client ServerManager Mock
-        self.servers_mock = self.app.client_manager.compute.servers
-        self.servers_mock.reset_mock()
-
-        # Get a shortcut to the compute client VolumeManager mock
-        self.servers_volumes_mock = self.app.client_manager.compute.volumes
-        self.servers_volumes_mock.reset_mock()
+        self.app.client_manager.sdk_connection = mock.Mock()
+        self.app.client_manager.sdk_connection.compute = mock.Mock()
+        self.app.client_manager.sdk_connection.volume = mock.Mock()
+        self.compute_client = self.app.client_manager.sdk_connection.compute
+        self.volume_client = self.app.client_manager.sdk_connection.volume
 
 
 class TestServerVolumeList(TestServerVolume):
@@ -37,20 +39,21 @@ class TestServerVolumeList(TestServerVolume):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_server()
-        self.volume_attachments = (
-            compute_fakes.FakeVolumeAttachment.create_volume_attachments())
+        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.volume_attachments = compute_fakes.create_volume_attachments()
 
-        self.servers_mock.get.return_value = self.server
-        self.servers_volumes_mock.get_server_volumes.return_value = (
+        self.compute_client.find_server.return_value = self.server
+        self.compute_client.volume_attachments.return_value = (
             self.volume_attachments)
 
         # Get the command object to test
         self.cmd = server_volume.ListServerVolume(self.app, None)
 
-    def test_server_volume_list(self):
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_list(self, sm_mock):
         self.app.client_manager.compute.api_version = \
             api_versions.APIVersion('2.1')
+        sm_mock.side_effect = [False, False, False, False]
 
         arglist = [
             self.server.id,
@@ -68,24 +71,25 @@ class TestServerVolumeList(TestServerVolume):
                 (
                     self.volume_attachments[0].id,
                     self.volume_attachments[0].device,
-                    self.volume_attachments[0].serverId,
-                    self.volume_attachments[0].volumeId,
+                    self.volume_attachments[0].server_id,
+                    self.volume_attachments[0].volume_id,
                 ),
                 (
                     self.volume_attachments[1].id,
                     self.volume_attachments[1].device,
-                    self.volume_attachments[1].serverId,
-                    self.volume_attachments[1].volumeId,
+                    self.volume_attachments[1].server_id,
+                    self.volume_attachments[1].volume_id,
                 ),
             ),
             tuple(data),
         )
-        self.servers_volumes_mock.get_server_volumes.assert_called_once_with(
-            self.server.id)
+        self.compute_client.volume_attachments.assert_called_once_with(
+            self.server,
+        )
 
-    def test_server_volume_list_with_tags(self):
-        self.app.client_manager.compute.api_version = \
-            api_versions.APIVersion('2.70')
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_list_with_tags(self, sm_mock):
+        sm_mock.side_effect = [False, True, False, False]
 
         arglist = [
             self.server.id,
@@ -105,27 +109,27 @@ class TestServerVolumeList(TestServerVolume):
                 (
                     self.volume_attachments[0].id,
                     self.volume_attachments[0].device,
-                    self.volume_attachments[0].serverId,
-                    self.volume_attachments[0].volumeId,
+                    self.volume_attachments[0].server_id,
+                    self.volume_attachments[0].volume_id,
                     self.volume_attachments[0].tag,
                 ),
                 (
                     self.volume_attachments[1].id,
                     self.volume_attachments[1].device,
-                    self.volume_attachments[1].serverId,
-                    self.volume_attachments[1].volumeId,
+                    self.volume_attachments[1].server_id,
+                    self.volume_attachments[1].volume_id,
                     self.volume_attachments[1].tag,
                 ),
             ),
             tuple(data),
         )
-        self.servers_volumes_mock.get_server_volumes.assert_called_once_with(
-            self.server.id)
-
-    def test_server_volume_list_with_delete_on_attachment(self):
-        self.app.client_manager.compute.api_version = \
-            api_versions.APIVersion('2.79')
+        self.compute_client.volume_attachments.assert_called_once_with(
+            self.server,
+        )
 
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_list_with_delete_on_attachment(self, sm_mock):
+        sm_mock.side_effect = [False, True, True, False]
         arglist = [
             self.server.id,
         ]
@@ -148,29 +152,30 @@ class TestServerVolumeList(TestServerVolume):
                 (
                     self.volume_attachments[0].id,
                     self.volume_attachments[0].device,
-                    self.volume_attachments[0].serverId,
-                    self.volume_attachments[0].volumeId,
+                    self.volume_attachments[0].server_id,
+                    self.volume_attachments[0].volume_id,
                     self.volume_attachments[0].tag,
                     self.volume_attachments[0].delete_on_termination,
                 ),
                 (
                     self.volume_attachments[1].id,
                     self.volume_attachments[1].device,
-                    self.volume_attachments[1].serverId,
-                    self.volume_attachments[1].volumeId,
+                    self.volume_attachments[1].server_id,
+                    self.volume_attachments[1].volume_id,
                     self.volume_attachments[1].tag,
                     self.volume_attachments[1].delete_on_termination,
                 ),
             ),
             tuple(data),
         )
-        self.servers_volumes_mock.get_server_volumes.assert_called_once_with(
-            self.server.id)
+        self.compute_client.volume_attachments.assert_called_once_with(
+            self.server,
+        )
 
-    def test_server_volume_list_with_attachment_ids(self):
-        self.app.client_manager.compute.api_version = \
-            api_versions.APIVersion('2.89')
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_list_with_attachment_ids(self, sm_mock):
 
+        sm_mock.side_effect = [True, True, True, True]
         arglist = [
             self.server.id,
         ]
@@ -193,28 +198,29 @@ class TestServerVolumeList(TestServerVolume):
             (
                 (
                     self.volume_attachments[0].device,
-                    self.volume_attachments[0].serverId,
-                    self.volume_attachments[0].volumeId,
+                    self.volume_attachments[0].server_id,
+                    self.volume_attachments[0].volume_id,
                     self.volume_attachments[0].tag,
                     self.volume_attachments[0].delete_on_termination,
                     self.volume_attachments[0].attachment_id,
-                    self.volume_attachments[0].bdm_uuid
+                    self.volume_attachments[0].bdm_id
 
                 ),
                 (
                     self.volume_attachments[1].device,
-                    self.volume_attachments[1].serverId,
-                    self.volume_attachments[1].volumeId,
+                    self.volume_attachments[1].server_id,
+                    self.volume_attachments[1].volume_id,
                     self.volume_attachments[1].tag,
                     self.volume_attachments[1].delete_on_termination,
                     self.volume_attachments[1].attachment_id,
-                    self.volume_attachments[1].bdm_uuid
+                    self.volume_attachments[1].bdm_id
                 ),
             ),
             tuple(data),
         )
-        self.servers_volumes_mock.get_server_volumes.assert_called_once_with(
-            self.server.id)
+        self.compute_client.volume_attachments.assert_called_once_with(
+            self.server,
+        )
 
 
 class TestServerVolumeUpdate(TestServerVolume):
@@ -222,21 +228,23 @@ class TestServerVolumeUpdate(TestServerVolume):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_server()
-        self.servers_mock.get.return_value = self.server
+        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.compute_client.find_server.return_value = self.server
+
+        self.volume = volume_fakes.create_one_sdk_volume()
+        self.volume_client.find_volume.return_value = self.volume
 
         # Get the command object to test
         self.cmd = server_volume.UpdateServerVolume(self.app, None)
 
     def test_server_volume_update(self):
-
         arglist = [
             self.server.id,
-            'foo',
+            self.volume.id,
         ]
         verifylist = [
             ('server', self.server.id),
-            ('volume', 'foo'),
+            ('volume', self.volume.id),
             ('delete_on_termination', None),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -244,67 +252,73 @@ class TestServerVolumeUpdate(TestServerVolume):
         result = self.cmd.take_action(parsed_args)
 
         # This is a no-op
-        self.servers_volumes_mock.update_server_volume.assert_not_called()
+        self.compute_client.update_volume_attachment.assert_not_called()
         self.assertIsNone(result)
 
-    def test_server_volume_update_with_delete_on_termination(self):
-        self.app.client_manager.compute.api_version = \
-            api_versions.APIVersion('2.85')
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_update_with_delete_on_termination(self, sm_mock):
+        sm_mock.return_value = True
 
         arglist = [
             self.server.id,
-            'foo',
+            self.volume.id,
             '--delete-on-termination',
         ]
         verifylist = [
             ('server', self.server.id),
-            ('volume', 'foo'),
+            ('volume', self.volume.id),
             ('delete_on_termination', True),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.servers_volumes_mock.update_server_volume.assert_called_once_with(
-            self.server.id, 'foo', 'foo',
-            delete_on_termination=True)
+        self.compute_client.update_volume_attachment.assert_called_once_with(
+            self.server,
+            self.volume,
+            delete_on_termination=True,
+        )
         self.assertIsNone(result)
 
-    def test_server_volume_update_with_preserve_on_termination(self):
-        self.app.client_manager.compute.api_version = \
-            api_versions.APIVersion('2.85')
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_update_with_preserve_on_termination(self, sm_mock):
+        sm_mock.return_value = True
 
         arglist = [
             self.server.id,
-            'foo',
+            self.volume.id,
             '--preserve-on-termination',
         ]
         verifylist = [
             ('server', self.server.id),
-            ('volume', 'foo'),
+            ('volume', self.volume.id),
             ('delete_on_termination', False),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.servers_volumes_mock.update_server_volume.assert_called_once_with(
-            self.server.id, 'foo', 'foo',
-            delete_on_termination=False)
+        self.compute_client.update_volume_attachment.assert_called_once_with(
+            self.server,
+            self.volume,
+            delete_on_termination=False
+        )
         self.assertIsNone(result)
 
-    def test_server_volume_update_with_delete_on_termination_pre_v285(self):
-        self.app.client_manager.compute.api_version = \
-            api_versions.APIVersion('2.84')
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_update_with_delete_on_termination_pre_v285(
+        self, sm_mock,
+    ):
+        sm_mock.return_value = False
 
         arglist = [
             self.server.id,
-            'foo',
+            self.volume.id,
             '--delete-on-termination',
         ]
         verifylist = [
             ('server', self.server.id),
-            ('volume', 'foo'),
+            ('volume', self.volume.id),
             ('delete_on_termination', True),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -312,20 +326,24 @@ class TestServerVolumeUpdate(TestServerVolume):
         self.assertRaises(
             exceptions.CommandError,
             self.cmd.take_action,
-            parsed_args)
+            parsed_args,
+        )
+        self.compute_client.update_volume_attachment.assert_not_called()
 
-    def test_server_volume_update_with_preserve_on_termination_pre_v285(self):
-        self.app.client_manager.compute.api_version = \
-            api_versions.APIVersion('2.84')
+    @mock.patch.object(sdk_utils, 'supports_microversion')
+    def test_server_volume_update_with_preserve_on_termination_pre_v285(
+        self, sm_mock,
+    ):
+        sm_mock.return_value = False
 
         arglist = [
             self.server.id,
-            'foo',
+            self.volume.id,
             '--preserve-on-termination',
         ]
         verifylist = [
             ('server', self.server.id),
-            ('volume', 'foo'),
+            ('volume', self.volume.id),
             ('delete_on_termination', False),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -333,4 +351,6 @@ class TestServerVolumeUpdate(TestServerVolume):
         self.assertRaises(
             exceptions.CommandError,
             self.cmd.take_action,
-            parsed_args)
+            parsed_args,
+        )
+        self.compute_client.update_volume_attachment.assert_not_called()

openstackclient/tests/unit/identity/v3/test_access_rule.py

@@ -14,10 +14,9 @@
 #
 
 import copy
-from unittest import mock
 
+from keystoneclient import exceptions as identity_exc
 from osc_lib import exceptions
-from osc_lib import utils
 
 from openstackclient.identity.v3 import access_rule
 from openstackclient.tests.unit import fakes
@@ -69,10 +68,13 @@ class TestAccessRuleDelete(TestAccessRule):
         )
         self.assertIsNone(result)
 
-    @mock.patch.object(utils, 'find_resource')
-    def test_delete_multi_access_rules_with_exception(self, find_mock):
-        find_mock.side_effect = [self.access_rules_mock.get.return_value,
-                                 exceptions.CommandError]
+    def test_delete_multi_access_rules_with_exception(self):
+        # mock returns for common.get_resource_by_id
+        mock_get = self.access_rules_mock.get
+        mock_get.side_effect = [
+            mock_get.return_value,
+            identity_exc.NotFound,
+        ]
         arglist = [
             identity_fakes.access_rule_id,
             'nonexistent_access_rule',
@@ -89,12 +91,10 @@ class TestAccessRuleDelete(TestAccessRule):
             self.assertEqual('1 of 2 access rules failed to'
                              ' delete.', str(e))
 
-        find_mock.assert_any_call(self.access_rules_mock,
-                                  identity_fakes.access_rule_id)
-        find_mock.assert_any_call(self.access_rules_mock,
-                                  'nonexistent_access_rule')
+        mock_get.assert_any_call(identity_fakes.access_rule_id)
+        mock_get.assert_any_call('nonexistent_access_rule')
 
-        self.assertEqual(2, find_mock.call_count)
+        self.assertEqual(2, mock_get.call_count)
         self.access_rules_mock.delete.assert_called_once_with(
             identity_fakes.access_rule_id)
 

openstackclient/tests/unit/network/v2/fakes.py

@@ -1066,11 +1066,13 @@ class FakeFloatingIPPortForwarding(object):
     """"Fake one or more Port forwarding"""
 
     @staticmethod
-    def create_one_port_forwarding(attrs=None):
+    def create_one_port_forwarding(attrs=None, use_range=False):
         """Create a fake Port Forwarding.
 
         :param Dictionary attrs:
             A dictionary with all attributes
+        :param Boolean use_range:
+            A boolean which defines if we will use ranges or not
         :return:
             A FakeResource object with name, id, etc.
         """
@@ -1084,13 +1086,29 @@ class FakeFloatingIPPortForwarding(object):
             'floatingip_id': floatingip_id,
             'internal_port_id': 'internal-port-id-' + uuid.uuid4().hex,
             'internal_ip_address': '192.168.1.2',
-            'internal_port': randint(1, 65535),
-            'external_port': randint(1, 65535),
             'protocol': 'tcp',
             'description': 'some description',
             'location': 'MUNCHMUNCHMUNCH',
         }
 
+        if use_range:
+            port_range = randint(0, 100)
+            internal_start = randint(1, 65535 - port_range)
+            internal_end = internal_start + port_range
+            internal_range = ':'.join(map(str, [internal_start, internal_end]))
+            external_start = randint(1, 65535 - port_range)
+            external_end = external_start + port_range
+            external_range = ':'.join(map(str, [external_start, external_end]))
+            port_forwarding_attrs['internal_port_range'] = internal_range
+            port_forwarding_attrs['external_port_range'] = external_range
+            port_forwarding_attrs['internal_port'] = None
+            port_forwarding_attrs['external_port'] = None
+        else:
+            port_forwarding_attrs['internal_port'] = randint(1, 65535)
+            port_forwarding_attrs['external_port'] = randint(1, 65535)
+            port_forwarding_attrs['internal_port_range'] = ''
+            port_forwarding_attrs['external_port_range'] = ''
+
         # Overwrite default attributes.
         port_forwarding_attrs.update(attrs)
 
@@ -1101,25 +1119,28 @@ class FakeFloatingIPPortForwarding(object):
         return port_forwarding
 
     @staticmethod
-    def create_port_forwardings(attrs=None, count=2):
+    def create_port_forwardings(attrs=None, count=2, use_range=False):
         """Create multiple fake Port Forwarding.
 
           :param Dictionary attrs:
               A dictionary with all attributes
           :param int count:
               The number of Port Forwarding rule to fake
+          :param Boolean use_range:
+              A boolean which defines if we will use ranges or not
           :return:
               A list of FakeResource objects faking the Port Forwardings
           """
         port_forwardings = []
         for i in range(0, count):
             port_forwardings.append(
-                FakeFloatingIPPortForwarding.create_one_port_forwarding(attrs)
+                FakeFloatingIPPortForwarding.create_one_port_forwarding(
+                    attrs, use_range=use_range)
             )
         return port_forwardings
 
     @staticmethod
-    def get_port_forwardings(port_forwardings=None, count=2):
+    def get_port_forwardings(port_forwardings=None, count=2, use_range=False):
         """Get a list of faked Port Forwardings.
 
         If port forwardings list is provided, then initialize the Mock object
@@ -1129,13 +1150,16 @@ class FakeFloatingIPPortForwarding(object):
             A list of FakeResource objects faking port forwardings
         :param int count:
             The number of Port Forwardings to fake
+        :param Boolean use_range:
+            A boolean which defines if we will use ranges or not
         :return:
             An iterable Mock object with side_effect set to a list of faked
             Port Forwardings
         """
         if port_forwardings is None:
             port_forwardings = (
-                FakeFloatingIPPortForwarding.create_port_forwardings(count)
+                FakeFloatingIPPortForwarding.create_port_forwardings(
+                    count, use_range=use_range)
             )
 
         return mock.Mock(side_effect=port_forwardings)