python-openstackclient 6.6.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

openstackclient/tests/unit/volume/v3/fakes.py

@@ -10,16 +10,23 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+import copy
 import random
+import re
 from unittest import mock
 import uuid
 
 from cinderclient import api_versions
+from keystoneauth1 import discover
 from openstack.block_storage.v3 import _proxy
 from openstack.block_storage.v3 import availability_zone as _availability_zone
+from openstack.block_storage.v3 import backup as _backup
 from openstack.block_storage.v3 import extension as _extension
+from openstack.block_storage.v3 import limits as _limits
 from openstack.block_storage.v3 import resource_filter as _filters
 from openstack.block_storage.v3 import volume as _volume
+from openstack.compute.v2 import _proxy as _compute_proxy
+from openstack.image.v2 import _proxy as _image_proxy
 
 from openstackclient.tests.unit import fakes
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
@@ -33,10 +40,14 @@ class FakeVolumeClient:
         self.management_url = kwargs['endpoint']
         self.api_version = api_versions.APIVersion('3.0')
 
-        self.availability_zones = mock.Mock()
-        self.availability_zones.resource_class = fakes.FakeResource(None, {})
         self.attachments = mock.Mock()
         self.attachments.resource_class = fakes.FakeResource(None, {})
+        self.availability_zones = mock.Mock()
+        self.availability_zones.resource_class = fakes.FakeResource(None, {})
+        self.backups = mock.Mock()
+        self.backups.resource_class = fakes.FakeResource(None, {})
+        self.consistencygroups = mock.Mock()
+        self.consistencygroups.resource_class = fakes.FakeResource(None, {})
         self.clusters = mock.Mock()
         self.clusters.resource_class = fakes.FakeResource(None, {})
         self.groups = mock.Mock()
@@ -47,18 +58,24 @@ class FakeVolumeClient:
         self.group_types.resource_class = fakes.FakeResource(None, {})
         self.messages = mock.Mock()
         self.messages.resource_class = fakes.FakeResource(None, {})
-        self.quota_classes = mock.Mock()
-        self.quota_classes.resource_class = fakes.FakeResource(None, {})
-        self.quotas = mock.Mock()
-        self.quotas.resource_class = fakes.FakeResource(None, {})
         self.resource_filters = mock.Mock()
         self.resource_filters.resource_class = fakes.FakeResource(None, {})
-        self.volumes = mock.Mock()
-        self.volumes.resource_class = fakes.FakeResource(None, {})
+        self.restores = mock.Mock()
+        self.restores.resource_class = fakes.FakeResource(None, {})
+        self.transfers = mock.Mock()
+        self.transfers.resource_class = fakes.FakeResource(None, {})
+        self.volume_encryption_types = mock.Mock()
+        self.volume_encryption_types.resource_class = fakes.FakeResource(
+            None, {}
+        )
         self.volume_snapshots = mock.Mock()
         self.volume_snapshots.resource_class = fakes.FakeResource(None, {})
+        self.volume_type_access = mock.Mock()
+        self.volume_type_access.resource_class = fakes.FakeResource(None, {})
         self.volume_types = mock.Mock()
         self.volume_types.resource_class = fakes.FakeResource(None, {})
+        self.volumes = mock.Mock()
+        self.volumes.resource_class = fakes.FakeResource(None, {})
         self.services = mock.Mock()
         self.services.resource_class = fakes.FakeResource(None, {})
         self.workers = mock.Mock()
@@ -80,32 +97,56 @@ class FakeClientMixin:
             spec=_proxy.Proxy,
         )
         self.volume_sdk_client = self.app.client_manager.sdk_connection.volume
+        self.set_volume_api_version()  # default to the lowest
+
+    def set_volume_api_version(self, version: str = '3.0'):
+        """Set a fake block storage API version.
 
+        :param version: The fake microversion to "support". This should be a
+            string of format '3.xx'.
+        :returns: None
+        """
+        assert re.match(r'3.\d+', version)
 
-class TestVolume(FakeClientMixin, utils.TestCommand):
+        self.volume_client.api_version = api_versions.APIVersion(version)
+
+        self.volume_sdk_client.default_microversion = version
+        self.volume_sdk_client.get_endpoint_data.return_value = (
+            discover.EndpointData(
+                min_microversion='3.0',  # cinder has not bumped this yet
+                max_microversion=version,
+            )
+        )
+
+
+class TestVolume(
+    identity_fakes.FakeClientMixin,
+    FakeClientMixin,
+    utils.TestCommand,
+):
     def setUp(self):
         super().setUp()
 
-        self.app.client_manager.identity = identity_fakes.FakeIdentityv3Client(
-            endpoint=fakes.AUTH_URL, token=fakes.AUTH_TOKEN
+        # avoid circular imports by defining this manually rather than using
+        # openstackclient.tests.unit.compute.v2.fakes.FakeClientMixin
+        # TODO(stephenfin): Rename to 'compute_client' once all commands are
+        # migrated to SDK
+        self.app.client_manager.sdk_connection.compute = mock.Mock(
+            _compute_proxy.Proxy
         )
-
-        # avoid circular imports
-        from openstackclient.tests.unit.compute.v2 import (
-            fakes as compute_fakes,
+        self.compute_sdk_client = (
+            self.app.client_manager.sdk_connection.compute
         )
 
-        self.app.client_manager.compute = compute_fakes.FakeComputev2Client(
-            endpoint=fakes.AUTH_URL,
-            token=fakes.AUTH_TOKEN,
-        )
-        self.compute_client = self.app.client_manager.compute
+        # avoid circular imports by defining this manually rather than using
+        # openstackclient.tests.unit.image.v2.fakes.FakeClientMixin
+        self.app.client_manager.image = mock.Mock(spec=_image_proxy.Proxy)
+        self.image_client = self.app.client_manager.image
 
 
 # TODO(stephenfin): Check if the responses are actually the same
 create_one_snapshot = volume_v2_fakes.create_one_snapshot
-create_one_volume = volume_v2_fakes.create_one_volume
-create_one_volume_type = volume_v2_fakes.create_one_volume_type
+create_one_service = volume_v2_fakes.create_one_service
 
 
 def create_one_availability_zone(attrs=None):
@@ -148,6 +189,54 @@ def create_availability_zones(attrs=None, count=2):
     return availability_zones
 
 
+def create_one_consistency_group(attrs=None):
+    """Create a fake consistency group.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object with id, name, description, etc.
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    consistency_group_info = {
+        "id": 'backup-id-' + uuid.uuid4().hex,
+        "name": 'backup-name-' + uuid.uuid4().hex,
+        "description": 'description-' + uuid.uuid4().hex,
+        "status": "error",
+        "availability_zone": 'zone' + uuid.uuid4().hex,
+        "created_at": 'time-' + uuid.uuid4().hex,
+        "volume_types": ['volume-type1'],
+    }
+
+    # Overwrite default attributes.
+    consistency_group_info.update(attrs)
+
+    consistency_group = fakes.FakeResource(
+        info=copy.deepcopy(consistency_group_info), loaded=True
+    )
+    return consistency_group
+
+
+def create_consistency_groups(attrs=None, count=2):
+    """Create multiple fake consistency groups.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of consistency groups to fake
+    :return:
+        A list of FakeResource objects faking the consistency groups
+    """
+    consistency_groups = []
+    for i in range(0, count):
+        consistency_group = create_one_consistency_group(attrs)
+        consistency_groups.append(consistency_group)
+
+    return consistency_groups
+
+
 def create_one_extension(attrs=None):
     """Create a fake extension.
 
@@ -179,6 +268,85 @@ def create_one_extension(attrs=None):
     return extension
 
 
+def create_one_backup(attrs=None):
+    """Create a fake backup.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return: A fake
+        openstack.block_storage.v3.backup.Backup object
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    backup_info = {
+        "availability_zone": 'zone' + uuid.uuid4().hex,
+        "container": 'container-' + uuid.uuid4().hex,
+        "created_at": 'time-' + uuid.uuid4().hex,
+        "data_timestamp": 'time-' + uuid.uuid4().hex,
+        "description": 'description-' + uuid.uuid4().hex,
+        "encryption_key_id": None,
+        "fail_reason": "Service not found for creating backup.",
+        "has_dependent_backups": False,
+        "id": 'backup-id-' + uuid.uuid4().hex,
+        "is_incremental": False,
+        "metadata": {},
+        "name": 'backup-name-' + uuid.uuid4().hex,
+        "object_count": None,
+        "project_id": uuid.uuid4().hex,
+        "size": random.randint(1, 20),
+        "snapshot_id": 'snapshot-id' + uuid.uuid4().hex,
+        "status": "error",
+        "updated_at": 'time-' + uuid.uuid4().hex,
+        "user_id": uuid.uuid4().hex,
+        "volume_id": 'volume-id-' + uuid.uuid4().hex,
+    }
+
+    # Overwrite default attributes.
+    backup_info.update(attrs)
+
+    backup = _backup.Backup(**backup_info)
+    return backup
+
+
+def create_backups(attrs=None, count=2):
+    """Create multiple fake backups.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of backups to fake
+    :return: A list of fake
+        openstack.block_storage.v3.backup.Backup objects
+    """
+    backups = []
+    for i in range(0, count):
+        backup = create_one_backup(attrs)
+        backups.append(backup)
+
+    return backups
+
+
+def get_backups(backups=None, count=2):
+    """Get an iterable MagicMock object with a list of faked backups.
+
+    If backups list is provided, then initialize the Mock object with the
+    list. Otherwise create one.
+
+    :param List backups:
+        A list of FakeResource objects faking backups
+    :param Integer count:
+        The number of backups to be faked
+    :return
+        An iterable Mock object with side_effect set to a list of faked
+        backups
+    """
+    if backups is None:
+        backups = create_backups(count)
+
+    return mock.Mock(side_effect=backups)
+
+
 def create_one_cluster(attrs=None):
     """Create a fake service cluster.
 
@@ -224,6 +392,86 @@ def create_clusters(attrs=None, count=2):
     return clusters
 
 
+def create_one_encryption_volume_type(attrs=None):
+    """Create a fake encryption volume type.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object with volume_type_id etc.
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    encryption_info = {
+        "volume_type_id": 'type-id-' + uuid.uuid4().hex,
+        'provider': 'LuksEncryptor',
+        'cipher': None,
+        'key_size': None,
+        'control_location': 'front-end',
+    }
+
+    # Overwrite default attributes.
+    encryption_info.update(attrs)
+
+    encryption_type = fakes.FakeResource(
+        info=copy.deepcopy(encryption_info), loaded=True
+    )
+    return encryption_type
+
+
+def create_limits(attrs=None):
+    """Create a fake limits object."""
+    attrs = attrs or {}
+
+    limits_attrs = {
+        'absolute': {
+            'totalSnapshotsUsed': 1,
+            'maxTotalBackups': 10,
+            'maxTotalVolumeGigabytes': 1000,
+            'maxTotalSnapshots': 10,
+            'maxTotalBackupGigabytes': 1000,
+            'totalBackupGigabytesUsed': 0,
+            'maxTotalVolumes': 10,
+            'totalVolumesUsed': 4,
+            'totalBackupsUsed': 0,
+            'totalGigabytesUsed': 35,
+        },
+        'rate': [
+            {
+                "uri": "*",
+                "limit": [
+                    {
+                        "value": 10,
+                        "verb": "POST",
+                        "remaining": 2,
+                        "unit": "MINUTE",
+                        "next-available": "2011-12-15T22:42:45Z",
+                    },
+                    {
+                        "value": 10,
+                        "verb": "PUT",
+                        "remaining": 2,
+                        "unit": "MINUTE",
+                        "next-available": "2011-12-15T22:42:45Z",
+                    },
+                    {
+                        "value": 100,
+                        "verb": "DELETE",
+                        "remaining": 100,
+                        "unit": "MINUTE",
+                        "next-available": "2011-12-15T22:42:45Z",
+                    },
+                ],
+            }
+        ],
+    }
+    limits_attrs.update(attrs)
+
+    limits = _limits.Limit(**limits_attrs)
+    return limits
+
+
 def create_one_resource_filter(attrs=None):
     """Create a fake resource filter.
 
@@ -265,6 +513,172 @@ def create_resource_filters(attrs=None, count=2):
     return resource_filters
 
 
+def create_one_transfer(attrs=None):
+    """Create a fake transfer.
+
+    :param dict attrs:
+        A dictionary with all attributes of Transfer Request
+    :return:
+        A FakeResource object with volume_id, name, id.
+    """
+    # Set default attribute
+    transfer_info = {
+        'volume_id': 'volume-id-' + uuid.uuid4().hex,
+        'name': 'fake_transfer_name',
+        'id': 'id-' + uuid.uuid4().hex,
+        'links': 'links-' + uuid.uuid4().hex,
+    }
+
+    # Overwrite default attributes if there are some attributes set
+    attrs = attrs or {}
+
+    transfer_info.update(attrs)
+
+    transfer = fakes.FakeResource(None, transfer_info, loaded=True)
+
+    return transfer
+
+
+def create_transfers(attrs=None, count=2):
+    """Create multiple fake transfers.
+
+    :param dict attrs:
+        A dictionary with all attributes of transfer
+    :param Integer count:
+        The number of transfers to be faked
+    :return:
+        A list of FakeResource objects
+    """
+    transfers = []
+    for n in range(0, count):
+        transfers.append(create_one_transfer(attrs))
+
+    return transfers
+
+
+def get_transfers(transfers=None, count=2):
+    """Get an iterable MagicMock object with a list of faked transfers.
+
+    If transfers list is provided, then initialize the Mock object with the
+    list. Otherwise create one.
+
+    :param List transfers:
+        A list of FakeResource objects faking transfers
+    :param Integer count:
+        The number of transfers to be faked
+    :return
+        An iterable Mock object with side_effect set to a list of faked
+        transfers
+    """
+    if transfers is None:
+        transfers = create_transfers(count)
+
+    return mock.Mock(side_effect=transfers)
+
+
+def create_one_type_access(attrs=None):
+    """Create a fake volume type access for project.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with  Volume_type_ID and Project_ID.
+    """
+    if attrs is None:
+        attrs = {}
+
+    # Set default attributes.
+    type_access_attrs = {
+        'volume_type_id': 'volume-type-id-' + uuid.uuid4().hex,
+        'project_id': 'project-id-' + uuid.uuid4().hex,
+    }
+
+    # Overwrite default attributes.
+    type_access_attrs.update(attrs)
+
+    type_access = fakes.FakeResource(None, type_access_attrs, loaded=True)
+
+    return type_access
+
+
+def create_one_volume(attrs=None):
+    """Create a fake volume.
+
+    :param dict attrs:
+        A dictionary with all attributes of volume
+    :return:
+        A FakeResource object with id, name, status, etc.
+    """
+    attrs = attrs or {}
+
+    # Set default attribute
+    volume_info = {
+        'id': 'volume-id' + uuid.uuid4().hex,
+        'name': 'volume-name' + uuid.uuid4().hex,
+        'description': 'description' + uuid.uuid4().hex,
+        'status': random.choice(['available', 'in_use']),
+        'size': random.randint(1, 20),
+        'volume_type': random.choice(['fake_lvmdriver-1', 'fake_lvmdriver-2']),
+        'bootable': random.randint(0, 1),
+        'metadata': {
+            'key' + uuid.uuid4().hex: 'val' + uuid.uuid4().hex,
+            'key' + uuid.uuid4().hex: 'val' + uuid.uuid4().hex,
+            'key' + uuid.uuid4().hex: 'val' + uuid.uuid4().hex,
+        },
+        'snapshot_id': random.randint(1, 5),
+        'availability_zone': 'zone' + uuid.uuid4().hex,
+        'attachments': [
+            {
+                'device': '/dev/' + uuid.uuid4().hex,
+                'server_id': uuid.uuid4().hex,
+            },
+        ],
+    }
+
+    # Overwrite default attributes if there are some attributes set
+    volume_info.update(attrs)
+
+    volume = fakes.FakeResource(None, volume_info, loaded=True)
+    return volume
+
+
+def create_volumes(attrs=None, count=2):
+    """Create multiple fake volumes.
+
+    :param dict attrs:
+        A dictionary with all attributes of volume
+    :param Integer count:
+        The number of volumes to be faked
+    :return:
+        A list of FakeResource objects
+    """
+    volumes = []
+    for n in range(0, count):
+        volumes.append(create_one_volume(attrs))
+
+    return volumes
+
+
+def get_volumes(volumes=None, count=2):
+    """Get an iterable MagicMock object with a list of faked volumes.
+
+    If volumes list is provided, then initialize the Mock object with the
+    list. Otherwise create one.
+
+    :param List volumes:
+        A list of FakeResource objects faking volumes
+    :param Integer count:
+        The number of volumes to be faked
+    :return
+        An iterable Mock object with side_effect set to a list of faked
+        volumes
+    """
+    if volumes is None:
+        volumes = create_volumes(count)
+
+    return mock.Mock(side_effect=volumes)
+
+
 def create_one_sdk_volume(attrs=None):
     """Create a fake volume.
 
@@ -603,6 +1017,75 @@ def get_volume_attachments(attachments=None, count=2):
     return mock.Mock(side_effect=attachments)
 
 
+def create_one_volume_type(attrs=None, methods=None):
+    """Create a fake volume type.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param dict methods:
+        A dictionary with all methods
+    :return:
+        A FakeResource object with id, name, description, etc.
+    """
+    attrs = attrs or {}
+    methods = methods or {}
+
+    # Set default attributes.
+    volume_type_info = {
+        "id": 'type-id-' + uuid.uuid4().hex,
+        "name": 'type-name-' + uuid.uuid4().hex,
+        "description": 'type-description-' + uuid.uuid4().hex,
+        "extra_specs": {"foo": "bar"},
+        "is_public": True,
+    }
+
+    # Overwrite default attributes.
+    volume_type_info.update(attrs)
+
+    volume_type = fakes.FakeResource(
+        info=copy.deepcopy(volume_type_info), methods=methods, loaded=True
+    )
+    return volume_type
+
+
+def create_volume_types(attrs=None, count=2):
+    """Create multiple fake volume_types.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of types to fake
+    :return:
+        A list of FakeResource objects faking the types
+    """
+    volume_types = []
+    for i in range(0, count):
+        volume_type = create_one_volume_type(attrs)
+        volume_types.append(volume_type)
+
+    return volume_types
+
+
+def get_volume_types(volume_types=None, count=2):
+    """Get an iterable MagicMock object with a list of faked volume types.
+
+    If volume_types list is provided, then initialize the Mock object with
+    the list. Otherwise create one.
+
+    :param List volume_types:
+        A list of FakeResource objects faking volume types
+    :param Integer count:
+        The number of volume types to be faked
+    :return
+        An iterable Mock object with side_effect set to a list of faked
+        volume types
+    """
+    if volume_types is None:
+        volume_types = create_volume_types(count)
+
+    return mock.Mock(side_effect=volume_types)
+
+
 def create_service_log_level_entry(attrs=None):
     service_log_level_info = {
         'host': 'host_test',

openstackclient/tests/unit/volume/v3/test_block_storage_cleanup.py

@@ -12,7 +12,6 @@
 
 import uuid
 
-from cinderclient import api_versions
 from osc_lib import exceptions
 
 from openstackclient.tests.unit.volume.v3 import fakes as volume_fakes
@@ -40,7 +39,7 @@ class TestBlockStorageCleanup(TestBlockStorage):
         self.cmd = block_storage_cleanup.BlockStorageCleanup(self.app, None)
 
     def test_cleanup(self):
-        self.volume_client.api_version = api_versions.APIVersion('3.24')
+        self.set_volume_api_version('3.24')
 
         arglist = []
         verifylist = [
@@ -96,7 +95,7 @@ class TestBlockStorageCleanup(TestBlockStorage):
         )
 
     def test_cleanup_with_args(self):
-        self.volume_client.api_version = api_versions.APIVersion('3.24')
+        self.set_volume_api_version('3.24')
 
         fake_cluster = 'fake-cluster'
         fake_host = 'fake-host'