python-openstackclient 8.2.0__py3-none-any.whl → 9.0.0__py3-none-any.whl

openstackclient/tests/functional/identity/v3/test_role_assignment.py

@@ -62,6 +62,47 @@ class RoleAssignmentTests(common.IdentityTests):
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
+    def test_role_assignment_list_group_domain(self):
+        domain_name_A = self._create_dummy_domain()
+        domain_name_B = self._create_dummy_domain()
+        role_name = self._create_dummy_role()
+        group_name = 'group_name'
+        self.openstack(f'group create --domain {domain_name_A} {group_name}')
+        self.addCleanup(
+            self.openstack,
+            f'group delete --domain {domain_name_A} {group_name}',
+        )
+        self.openstack(f'group create --domain {domain_name_B} {group_name}')
+        self.addCleanup(
+            self.openstack,
+            f'group delete --domain {domain_name_B} {group_name}',
+        )
+        raw_output = self.openstack(
+            'role add '
+            f'--project {self.project_name} '
+            f'--group {group_name} --group-domain {domain_name_A} '
+            f'{role_name}'
+        )
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            f'--project {self.project_name} '
+            f'--group {group_name} --group-domain {domain_name_A} '
+            f'{role_name}',
+        )
+        self.assertEqual('', raw_output.strip())
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--group {group_name} --group-domain {domain_name_A} '
+        )
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--group {group_name} --group-domain {domain_name_B} '
+        )
+        self.assertEqual('', raw_output.strip())
+
     def test_role_assignment_list_domain(self):
         role_name = self._create_dummy_role()
         username = self._create_dummy_user()
@@ -85,6 +126,89 @@ class RoleAssignmentTests(common.IdentityTests):
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
+    def test_role_assignment_list_user_domain(self):
+        domain_name_A = self._create_dummy_domain()
+        domain_name_B = self._create_dummy_domain()
+        role_name = self._create_dummy_role()
+        username = 'username'
+        self.openstack(f'user create --domain {domain_name_A} {username}')
+        self.addCleanup(
+            self.openstack, f'user delete --domain {domain_name_A} {username}'
+        )
+        self.openstack(f'user create --domain {domain_name_B} {username}')
+        self.addCleanup(
+            self.openstack, f'user delete --domain {domain_name_B} {username}'
+        )
+        raw_output = self.openstack(
+            'role add '
+            f'--project {self.project_name} '
+            f'--user {username} --user-domain {domain_name_A} '
+            f'{role_name}'
+        )
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            f'--project {self.project_name} '
+            f'--user {username} --user-domain {domain_name_A} '
+            f'{role_name}',
+        )
+        self.assertEqual('', raw_output.strip())
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--user {username} --user-domain {domain_name_A} '
+        )
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--user {username} --user-domain {domain_name_B} '
+        )
+        self.assertEqual('', raw_output.strip())
+
+    def test_role_assignment_list_role_domain(self):
+        domain_name_A = self._create_dummy_domain()
+        domain_name_B = self._create_dummy_domain()
+        role_name = 'role_name'
+        username = 'username'
+        self.openstack(f'role create --domain {domain_name_A} {role_name}')
+        self.addCleanup(
+            self.openstack, f'role delete --domain {domain_name_A} {role_name}'
+        )
+        self.openstack(f'role create --domain {domain_name_B} {role_name}')
+        self.addCleanup(
+            self.openstack, f'role delete --domain {domain_name_B} {role_name}'
+        )
+        self.openstack(f'user create --domain {domain_name_A} {username}')
+        self.addCleanup(
+            self.openstack, f'user delete --domain {domain_name_A} {username}'
+        )
+        raw_output = self.openstack(
+            'role add '
+            f'--user {username} --domain {domain_name_A} '
+            f'--role-domain {domain_name_A} '
+            f'{role_name}'
+        )
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            f'--user {username} --domain {domain_name_A} '
+            f'--role-domain {domain_name_A} '
+            f'{role_name}',
+        )
+        self.assertEqual('', raw_output.strip())
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--role {role_name} --role-domain {domain_name_A}'
+        )
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--role {role_name} --role-domain {domain_name_B}'
+        )
+        items = self.parse_listing(raw_output)
+        self.assertEqual('', raw_output.strip())
+
     def test_role_assignment_list_project(self):
         role_name = self._create_dummy_role()
         username = self._create_dummy_user()
@@ -108,6 +232,56 @@ class RoleAssignmentTests(common.IdentityTests):
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
+    def test_role_assignment_list_project_domain(self):
+        domain_name_A = self._create_dummy_domain()
+        domain_name_B = self._create_dummy_domain()
+        role_name = self._create_dummy_role()
+        project_name = 'project_name'
+        username = 'username'
+        self.openstack(
+            f'project create --domain {domain_name_A} {project_name}'
+        )
+        self.addCleanup(
+            self.openstack,
+            f'project delete --domain {domain_name_A} {project_name}',
+        )
+        self.openstack(
+            f'project create --domain {domain_name_B} {project_name}'
+        )
+        self.addCleanup(
+            self.openstack,
+            f'project delete --domain {domain_name_B} {project_name}',
+        )
+        self.openstack(f'user create --domain {domain_name_A} {username}')
+        self.addCleanup(
+            self.openstack, f'user delete --domain {domain_name_A} {username}'
+        )
+        raw_output = self.openstack(
+            'role add '
+            f'--project {project_name} --project-domain {domain_name_A} '
+            f'--user {username} --user-domain {domain_name_A} '
+            f'{role_name}'
+        )
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            f'--project {project_name} --project-domain {domain_name_A} '
+            f'--user {username} --user-domain {domain_name_A} '
+            f'{role_name}',
+        )
+        self.assertEqual('', raw_output.strip())
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--project {project_name} --project-domain {domain_name_A} '
+        )
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
+        raw_output = self.openstack(
+            f'role assignment list '
+            f'--project {project_name} --project-domain {domain_name_B} '
+        )
+        self.assertEqual('', raw_output.strip())
+
     def test_role_assignment_list_effective(self):
         raw_output = self.openstack('role assignment list --effective')
         items = self.parse_listing(raw_output)

openstackclient/tests/functional/image/v2/test_cache.py

@@ -0,0 +1,54 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import uuid
+
+from openstackclient.tests.functional.image import base
+
+
+class CacheTests(base.BaseImageTests):
+    """Functional tests for Cache commands"""
+
+    def test_cached_image(self):
+        """Test cached image operations including queue and clear"""
+        # Create test image
+        name = uuid.uuid4().hex
+        output = self.openstack(
+            f'image create {name}',
+            parse_output=True,
+        )
+        image_id = output["id"]
+        self.assertOutput(name, output['name'])
+
+        # Register cleanup for created image
+        self.addCleanup(
+            self.openstack, 'cached image delete ' + image_id, fail_ok=True
+        )
+        self.addCleanup(self.openstack, 'image delete ' + image_id)
+
+        # Queue image for caching
+        self.openstack('cached image queue ' + image_id)
+
+        # Verify queuing worked
+        cache_output = self.openstack('cached image list', parse_output=True)
+        self.assertIsInstance(cache_output, list)
+        image_ids = [img['ID'] for img in cache_output]
+        self.assertIn(image_id, image_ids)
+
+        # Clear cached images
+        self.openstack('cached image clear')
+
+        # Verify clearing worked
+        output = self.openstack('cached image list', parse_output=True)
+        if output:
+            image_ids = [img['ID'] for img in output]
+            self.assertNotIn(image_id, image_ids)

openstackclient/tests/functional/image/v2/test_metadef_objects.py

@@ -0,0 +1,69 @@
+# 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 openstackclient.tests.functional import base
+
+
+class MetadefObjectTests(base.TestCase):
+    def setUp(self):
+        super().setUp()
+        self.obj_name = self.getUniqueString('metadef-obj')
+        self.ns_name = self.getUniqueString('metadef-ns')
+        self.openstack(f"image metadef namespace create {self.ns_name}")
+        self.addCleanup(
+            lambda: self.openstack(
+                f"image metadef namespace delete {self.ns_name}"
+            )
+        )
+
+    def test_metadef_objects(self):
+        # CREATE
+        created = self.openstack(
+            (
+                "image metadef object create "
+                f"--namespace {self.ns_name} "
+                f"{self.obj_name}"
+            ),
+            parse_output=True,
+        )
+        self.addCleanup(
+            lambda: self.openstack(
+                f"image metadef object delete {self.ns_name} {self.obj_name}"
+            )
+        )
+        self.assertEqual(self.obj_name, created["name"])
+        self.assertEqual(self.ns_name, created["namespace_name"])
+
+        # UPDATE
+        new_name = f"{self.obj_name}-updated"
+        self.openstack(
+            "image metadef object update "
+            f"{self.ns_name} {self.obj_name} "
+            f"--name {new_name}"
+        )
+        self.obj_name = new_name
+
+        # READ (get)
+        shown = self.openstack(
+            f"image metadef object show {self.ns_name} {self.obj_name}",
+            parse_output=True,
+        )
+        self.assertEqual(self.obj_name, shown["name"])
+        self.assertEqual(self.ns_name, shown["namespace_name"])
+
+        # READ (list)
+        rows = self.openstack(
+            f"image metadef object list {self.ns_name}",
+            parse_output=True,
+        )
+        names = {row["name"] for row in rows}
+        self.assertIn(self.obj_name, names)

openstackclient/tests/functional/image/v2/test_metadef_resource_type.py

@@ -0,0 +1,55 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import uuid
+
+from openstackclient.tests.functional.image import base
+
+
+class ImageMetadefResourceTypeTests(base.BaseImageTests):
+    """Functional tests for image metadef resource type commands."""
+
+    def setUp(self):
+        super().setUp()
+
+        # Create unique namespace name using UUID
+        self.namespace_name = 'test-mdef-ns-' + uuid.uuid4().hex
+        self.resource_type_name = 'test-mdef-rt-' + uuid.uuid4().hex
+
+        # Create namespace
+        self.openstack('image metadef namespace create ' + self.namespace_name)
+        self.addCleanup(
+            self.openstack,
+            'image metadef namespace delete ' + self.namespace_name,
+        )
+
+    def test_metadef_resource_type(self):
+        """Test image metadef resource type commands"""
+
+        self.openstack(
+            'image metadef resource type association create '
+            f'{self.namespace_name} {self.resource_type_name}',
+        )
+        self.addCleanup(
+            self.openstack,
+            'image metadef resource type association delete '
+            f'{self.namespace_name} {self.resource_type_name}',
+        )
+
+        output = self.openstack(
+            'image metadef resource type list',
+            parse_output=True,
+        )
+
+        self.assertIn(
+            self.resource_type_name, [item['Name'] for item in output]
+        )

openstackclient/tests/functional/volume/v3/test_volume_snapshot.py

@@ -23,7 +23,7 @@ class VolumeSnapshotTests(common.BaseVolumeTests):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        # create a volume for all tests to create snapshot
+        # create a test volume used by all snapshot tests
         cmd_output = cls.openstack(
             'volume create ' + '--size 1 ' + cls.VOLLY,
             parse_output=True,
@@ -40,147 +40,57 @@ class VolumeSnapshotTests(common.BaseVolumeTests):
         finally:
             super().tearDownClass()
 
-    def test_volume_snapshot_delete(self):
-        """Test create, delete multiple"""
-        name1 = uuid.uuid4().hex
-        cmd_output = self.openstack(
-            'volume snapshot create ' + name1 + ' --volume ' + self.VOLLY,
-            parse_output=True,
-        )
-        self.assertEqual(
-            name1,
-            cmd_output["name"],
-        )
+    def test_volume_snapshot(self):
+        # create volume snapshot
+        name = uuid.uuid4().hex
 
-        name2 = uuid.uuid4().hex
         cmd_output = self.openstack(
-            'volume snapshot create ' + name2 + ' --volume ' + self.VOLLY,
+            'volume snapshot create '
+            + '--volume '
+            + self.VOLLY
+            + ' --description aaaa '
+            + '--property Alpha=a '
+            + name,
             parse_output=True,
         )
-        self.assertEqual(
-            name2,
-            cmd_output["name"],
-        )
-
-        self.wait_for_status('volume snapshot', name1, 'available')
-        self.wait_for_status('volume snapshot', name2, 'available')
+        snap_id = cmd_output['id']
 
-        del_output = self.openstack(
-            'volume snapshot delete ' + name1 + ' ' + name2
+        self.addCleanup(self.wait_for_delete, 'volume snapshot', snap_id)
+        # delete volume snapshot
+        self.addCleanup(
+            self.openstack,
+            'volume snapshot delete ' + snap_id,
         )
-        self.assertOutput('', del_output)
-        self.wait_for_delete('volume snapshot', name1)
-        self.wait_for_delete('volume snapshot', name2)
+        self.wait_for_status('volume snapshot', snap_id, 'available')
 
-    def test_volume_snapshot_list(self):
-        """Test create, list filter"""
-        name1 = uuid.uuid4().hex
-        cmd_output = self.openstack(
-            'volume snapshot create ' + name1 + ' --volume ' + self.VOLLY,
+        # show volume snapshot
+        snapshot_info = self.openstack(
+            'volume snapshot show ' + name,
             parse_output=True,
         )
-        self.addCleanup(self.wait_for_delete, 'volume snapshot', name1)
-        self.addCleanup(self.openstack, 'volume snapshot delete ' + name1)
-        self.assertEqual(
-            name1,
-            cmd_output["name"],
-        )
-        self.assertEqual(
-            self.VOLUME_ID,
-            cmd_output["volume_id"],
-        )
-        self.assertEqual(
-            1,
-            cmd_output["size"],
-        )
-        self.wait_for_status('volume snapshot', name1, 'available')
 
-        name2 = uuid.uuid4().hex
-        cmd_output = self.openstack(
-            'volume snapshot create ' + name2 + ' --volume ' + self.VOLLY,
-            parse_output=True,
-        )
-        self.addCleanup(self.wait_for_delete, 'volume snapshot', name2)
-        self.addCleanup(self.openstack, 'volume snapshot delete ' + name2)
-        self.assertEqual(
-            name2,
-            cmd_output["name"],
-        )
-        self.assertEqual(
-            self.VOLUME_ID,
-            cmd_output["volume_id"],
-        )
-        self.assertEqual(
-            1,
-            cmd_output["size"],
-        )
-        self.wait_for_status('volume snapshot', name2, 'available')
-        raw_output = self.openstack(
-            'volume snapshot set ' + '--state error ' + name2
-        )
-        self.assertOutput('', raw_output)
+        self.assertEqual(name, snapshot_info['name'])
+        self.assertEqual('aaaa', snapshot_info["description"])
+        self.assertEqual({'Alpha': 'a'}, snapshot_info["properties"])
 
-        # Test list --long, --status
+        # list volume snapshot --name
         cmd_output = self.openstack(
-            'volume snapshot list ' + '--long ' + '--status error',
+            'volume snapshot list --name ' + name,
             parse_output=True,
         )
-        names = [x["Name"] for x in cmd_output]
-        self.assertNotIn(name1, names)
-        self.assertIn(name2, names)
+        names = [x['Name'] for x in cmd_output]
+        self.assertIn(name, names)
 
-        # Test list --volume
+        # list volume snapshot --volume
         cmd_output = self.openstack(
             'volume snapshot list ' + '--volume ' + self.VOLLY,
             parse_output=True,
         )
         names = [x["Name"] for x in cmd_output]
-        self.assertIn(name1, names)
-        self.assertIn(name2, names)
+        self.assertIn(name, names)
 
-        # Test list --name
-        cmd_output = self.openstack(
-            'volume snapshot list ' + '--name ' + name1,
-            parse_output=True,
-        )
-        names = [x["Name"] for x in cmd_output]
-        self.assertIn(name1, names)
-        self.assertNotIn(name2, names)
-
-    def test_volume_snapshot_set(self):
-        """Test create, set, unset, show, delete volume snapshot"""
-        name = uuid.uuid4().hex
+        # set volume snapshot
         new_name = name + "_"
-        cmd_output = self.openstack(
-            'volume snapshot create '
-            + '--volume '
-            + self.VOLLY
-            + ' --description aaaa '
-            + '--property Alpha=a '
-            + name,
-            parse_output=True,
-        )
-        self.addCleanup(self.wait_for_delete, 'volume snapshot', new_name)
-        self.addCleanup(self.openstack, 'volume snapshot delete ' + new_name)
-        self.assertEqual(
-            name,
-            cmd_output["name"],
-        )
-        self.assertEqual(
-            1,
-            cmd_output["size"],
-        )
-        self.assertEqual(
-            'aaaa',
-            cmd_output["description"],
-        )
-        self.assertEqual(
-            {'Alpha': 'a'},
-            cmd_output["properties"],
-        )
-        self.wait_for_status('volume snapshot', name, 'available')
-
-        # Test volume snapshot set
         raw_output = self.openstack(
             'volume snapshot set '
             + '--name '
@@ -188,11 +98,10 @@ class VolumeSnapshotTests(common.BaseVolumeTests):
             + ' --description bbbb '
             + '--property Alpha=c '
             + '--property Beta=b '
-            + name,
+            + snap_id,
         )
         self.assertOutput('', raw_output)
 
-        # Show snapshot set result
         cmd_output = self.openstack(
             'volume snapshot show ' + new_name,
             parse_output=True,
@@ -201,10 +110,6 @@ class VolumeSnapshotTests(common.BaseVolumeTests):
             new_name,
             cmd_output["name"],
         )
-        self.assertEqual(
-            1,
-            cmd_output["size"],
-        )
         self.assertEqual(
             'bbbb',
             cmd_output["description"],
@@ -214,7 +119,7 @@ class VolumeSnapshotTests(common.BaseVolumeTests):
             cmd_output["properties"],
         )
 
-        # Test volume snapshot unset
+        # unset volume snapshot
         raw_output = self.openstack(
             'volume snapshot unset ' + '--property Alpha ' + new_name,
         )
@@ -229,16 +134,25 @@ class VolumeSnapshotTests(common.BaseVolumeTests):
             cmd_output["properties"],
         )
 
-        # Test volume snapshot set --no-property
+        # set volume snapshot --no-property, --state error
         raw_output = self.openstack(
-            'volume snapshot set ' + '--no-property ' + new_name,
+            'volume snapshot set '
+            + '--no-property '
+            + '--state error '
+            + new_name,
         )
         self.assertOutput('', raw_output)
+
         cmd_output = self.openstack(
             'volume snapshot show ' + new_name,
             parse_output=True,
         )
-        self.assertNotIn(
-            {'Beta': 'b'},
-            cmd_output["properties"],
+        self.assertEqual({}, cmd_output["properties"])
+
+        # list volume snapshot --long --status
+        cmd_output = self.openstack(
+            'volume snapshot list ' + '--long ' + '--status error',
+            parse_output=True,
         )
+        names = [x["Name"] for x in cmd_output]
+        self.assertIn(new_name, names)

openstackclient/tests/unit/common/test_command.py

@@ -14,9 +14,9 @@
 
 from unittest import mock
 
-from osc_lib.command import command
 from osc_lib import exceptions
 
+from openstackclient import command
 from openstackclient.tests.unit import fakes as test_fakes
 from openstackclient.tests.unit import utils as test_utils
 

openstackclient/tests/unit/common/test_extension.py

@@ -10,7 +10,6 @@
 #   License for the specific language governing permissions and limitations
 #   under the License.
 
-from unittest import mock
 
 from openstackclient.common import extension
 from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes
@@ -295,8 +294,8 @@ class TestExtensionShow(TestExtension):
 
         self.cmd = extension.ShowExtension(self.app, None)
 
-        self.app.client_manager.network.find_extension = mock.Mock(
-            return_value=self.extension_details
+        self.app.client_manager.network.find_extension.return_value = (
+            self.extension_details
         )
 
     def test_show_no_options(self):