python-openstackclient 7.2.1__py3-none-any.whl → 7.3.1__py3-none-any.whl

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

@@ -10,9 +10,13 @@
 #   License for the specific language governing permissions and limitations
 #   under the License.
 
-from unittest import mock
 from unittest.mock import call
 
+from openstack import exceptions as sdk_exceptions
+from openstack.identity.v3 import credential as _credential
+from openstack.identity.v3 import project as _project
+from openstack.identity.v3 import user as _user
+from openstack.test import fakes as sdk_fakes
 from osc_lib import exceptions
 
 from openstackclient.identity.v3 import credential
@@ -20,26 +24,9 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
 from openstackclient.tests.unit import utils
 
 
-class TestCredential(identity_fakes.TestIdentityv3):
-    def setUp(self):
-        super().setUp()
-
-        # Get a shortcut to the CredentialManager Mock
-        self.credentials_mock = self.identity_client.credentials
-        self.credentials_mock.reset_mock()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.identity_client.users
-        self.users_mock.reset_mock()
-
-        # Get a shortcut to the ProjectManager Mock
-        self.projects_mock = self.identity_client.projects
-        self.projects_mock.reset_mock()
-
-
-class TestCredentialCreate(TestCredential):
-    user = identity_fakes.FakeUser.create_one_user()
-    project = identity_fakes.FakeProject.create_one_project()
+class TestCredentialCreate(identity_fakes.TestIdentityv3):
+    user = sdk_fakes.generate_fake_resource(_user.User)
+    project = sdk_fakes.generate_fake_resource(_project.Project)
     columns = (
         'blob',
         'id',
@@ -51,12 +38,17 @@ class TestCredentialCreate(TestCredential):
     def setUp(self):
         super().setUp()
 
-        self.credential = identity_fakes.FakeCredential.create_one_credential(
-            attrs={'user_id': self.user.id, 'project_id': self.project.id}
+        self.credential = sdk_fakes.generate_fake_resource(
+            resource_type=_credential.Credential,
+            user_id=self.user.id,
+            project_id=self.project.id,
+            type='cert',
         )
-        self.credentials_mock.create.return_value = self.credential
-        self.users_mock.get.return_value = self.user
-        self.projects_mock.get.return_value = self.project
+        self.identity_sdk_client.create_credential.return_value = (
+            self.credential
+        )
+        self.identity_sdk_client.find_user.return_value = self.user
+        self.identity_sdk_client.find_project.return_value = self.project
         self.data = (
             self.credential.blob,
             self.credential.id,
@@ -86,7 +78,9 @@ class TestCredentialCreate(TestCredential):
             'blob': self.credential.blob,
             'project': None,
         }
-        self.credentials_mock.create.assert_called_once_with(**kwargs)
+        self.identity_sdk_client.create_credential.assert_called_once_with(
+            **kwargs
+        )
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
@@ -116,42 +110,48 @@ class TestCredentialCreate(TestCredential):
             'blob': self.credential.blob,
             'project': self.credential.project_id,
         }
-        self.credentials_mock.create.assert_called_once_with(**kwargs)
+        self.identity_sdk_client.create_credential.assert_called_once_with(
+            **kwargs
+        )
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
 
-class TestCredentialDelete(TestCredential):
-    credentials = identity_fakes.FakeCredential.create_credentials(count=2)
-
+class TestCredentialDelete(identity_fakes.TestIdentityv3):
     def setUp(self):
         super().setUp()
 
-        self.credentials_mock.delete.return_value = None
+        self.identity_sdk_client.delete_credential.return_value = None
 
         # Get the command object to test
         self.cmd = credential.DeleteCredential(self.app, None)
 
     def test_credential_delete(self):
+        credential = sdk_fakes.generate_fake_resource(
+            _credential.Credential,
+        )
         arglist = [
-            self.credentials[0].id,
+            credential.id,
         ]
         verifylist = [
-            ('credential', [self.credentials[0].id]),
+            ('credential', [credential.id]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.credentials_mock.delete.assert_called_with(
-            self.credentials[0].id,
+        self.identity_sdk_client.delete_credential.assert_called_with(
+            credential.id,
         )
         self.assertIsNone(result)
 
     def test_credential_multi_delete(self):
+        credentials = sdk_fakes.generate_fake_resources(
+            _credential.Credential, count=2
+        )
         arglist = []
-        for c in self.credentials:
+        for c in credentials:
             arglist.append(c.id)
         verifylist = [
             ('credential', arglist),
@@ -161,25 +161,26 @@ class TestCredentialDelete(TestCredential):
         result = self.cmd.take_action(parsed_args)
 
         calls = []
-        for c in self.credentials:
+        for c in credentials:
             calls.append(call(c.id))
-        self.credentials_mock.delete.assert_has_calls(calls)
+        self.identity_sdk_client.delete_credential.assert_has_calls(calls)
         self.assertIsNone(result)
 
     def test_credential_multi_delete_with_exception(self):
+        credential = sdk_fakes.generate_fake_resource(
+            _credential.Credential,
+        )
         arglist = [
-            self.credentials[0].id,
+            credential.id,
             'unexist_credential',
         ]
-        verifylist = [
-            ('credential', [self.credentials[0].id, 'unexist_credential'])
-        ]
+        verifylist = [('credential', [credential.id, 'unexist_credential'])]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        delete_mock_result = [None, exceptions.CommandError]
-        self.credentials_mock.delete = mock.Mock(
-            side_effect=delete_mock_result
-        )
+        self.identity_sdk_client.delete_credential.side_effect = [
+            None,
+            sdk_exceptions.NotFoundException,
+        ]
 
         try:
             self.cmd.take_action(parsed_args)
@@ -187,12 +188,16 @@ class TestCredentialDelete(TestCredential):
         except exceptions.CommandError as e:
             self.assertEqual('1 of 2 credential failed to delete.', str(e))
 
-        self.credentials_mock.delete.assert_any_call(self.credentials[0].id)
-        self.credentials_mock.delete.assert_any_call('unexist_credential')
+        self.identity_sdk_client.delete_credential.assert_any_call(
+            credential.id
+        )
+        self.identity_sdk_client.delete_credential.assert_any_call(
+            'unexist_credential'
+        )
 
 
-class TestCredentialList(TestCredential):
-    credential = identity_fakes.FakeCredential.create_one_credential()
+class TestCredentialList(identity_fakes.TestIdentityv3):
+    credential = sdk_fakes.generate_fake_resource(_credential.Credential)
 
     columns = ('ID', 'Type', 'User ID', 'Data', 'Project ID')
     data = (
@@ -208,10 +213,10 @@ class TestCredentialList(TestCredential):
     def setUp(self):
         super().setUp()
 
-        self.user = identity_fakes.FakeUser.create_one_user()
-        self.users_mock.get.return_value = self.user
+        self.user = sdk_fakes.generate_fake_resource(_user.User)
+        self.identity_sdk_client.find_user.return_value = self.user
 
-        self.credentials_mock.list.return_value = [self.credential]
+        self.identity_sdk_client.credentials.return_value = [self.credential]
 
         # Get the command object to test
         self.cmd = credential.ListCredential(self.app, None)
@@ -223,7 +228,7 @@ class TestCredentialList(TestCredential):
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.credentials_mock.list.assert_called_with()
+        self.identity_sdk_client.credentials.assert_called_with()
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, tuple(data))
 
@@ -246,15 +251,17 @@ class TestCredentialList(TestCredential):
             'user_id': self.user.id,
             'type': self.credential.type,
         }
-        self.users_mock.get.assert_called_with(self.credential.user_id)
-        self.credentials_mock.list.assert_called_with(**kwargs)
+        self.identity_sdk_client.find_user.assert_called_with(
+            self.credential.user_id, domain_id=None, ignore_missing=False
+        )
+        self.identity_sdk_client.credentials.assert_called_with(**kwargs)
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, tuple(data))
 
 
-class TestCredentialSet(TestCredential):
-    credential = identity_fakes.FakeCredential.create_one_credential()
+class TestCredentialSet(identity_fakes.TestIdentityv3):
+    credential = sdk_fakes.generate_fake_resource(_credential.Credential)
 
     def setUp(self):
         super().setUp()
@@ -343,7 +350,7 @@ class TestCredentialSet(TestCredential):
         self.assertIsNone(result)
 
 
-class TestCredentialShow(TestCredential):
+class TestCredentialShow(identity_fakes.TestIdentityv3):
     columns = (
         'blob',
         'id',
@@ -355,8 +362,10 @@ class TestCredentialShow(TestCredential):
     def setUp(self):
         super().setUp()
 
-        self.credential = identity_fakes.FakeCredential.create_one_credential()
-        self.credentials_mock.get.return_value = self.credential
+        self.credential = sdk_fakes.generate_fake_resource(
+            _credential.Credential
+        )
+        self.identity_sdk_client.get_credential.return_value = self.credential
         self.data = (
             self.credential.blob,
             self.credential.id,
@@ -378,6 +387,8 @@ class TestCredentialShow(TestCredential):
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.credentials_mock.get.assert_called_once_with(self.credential.id)
+        self.identity_sdk_client.get_credential.assert_called_once_with(
+            self.credential.id
+        )
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)

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

@@ -11,7 +11,6 @@
 #   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 unittest.mock import call
@@ -914,8 +913,7 @@ class TestProjectList(TestProject):
         auth_ref = identity_fakes.fake_auth_ref(
             identity_fakes.TOKEN_WITH_PROJECT_ID,
         )
-        ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = ar_mock
+        self.app.client_manager.auth_ref = auth_ref
 
         arglist = [
             '--my-projects',

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

@@ -11,55 +11,44 @@
 #   under the License.
 #
 
-import copy
+
+from openstack.identity.v3 import region as _region
+from openstack.test import fakes as sdk_fakes
 
 from openstackclient.identity.v3 import region
-from openstackclient.tests.unit import fakes
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
 
 
-class TestRegion(identity_fakes.TestIdentityv3):
-    def setUp(self):
-        super().setUp()
-
-        # Get a shortcut to the RegionManager Mock
-        self.regions_mock = self.identity_client.regions
-        self.regions_mock.reset_mock()
-
-
-class TestRegionCreate(TestRegion):
+class TestRegionCreate(identity_fakes.TestIdentityv3):
+    region = sdk_fakes.generate_fake_resource(_region.Region)
     columns = (
+        'region',
         'description',
         'parent_region',
-        'region',
     )
     datalist = (
-        identity_fakes.region_description,
-        identity_fakes.region_parent_region_id,
-        identity_fakes.region_id,
+        region.id,
+        region.description,
+        region.parent_region_id,
     )
 
     def setUp(self):
         super().setUp()
 
-        self.regions_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.REGION),
-            loaded=True,
-        )
+        self.identity_sdk_client.create_region.return_value = self.region
 
         # Get the command object to test
         self.cmd = region.CreateRegion(self.app, None)
 
     def test_region_create_description(self):
         arglist = [
-            identity_fakes.region_id,
+            self.region.id,
             '--description',
-            identity_fakes.region_description,
+            self.region.description,
         ]
         verifylist = [
-            ('region', identity_fakes.region_id),
-            ('description', identity_fakes.region_description),
+            ('region', self.region.id),
+            ('description', self.region.description),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -70,21 +59,21 @@ class TestRegionCreate(TestRegion):
 
         # Set expected values
         kwargs = {
-            'description': identity_fakes.region_description,
-            'id': identity_fakes.region_id,
-            'parent_region': None,
+            'description': self.region.description,
+            'id': self.region.id,
+            'parent_region_id': None,
         }
-        self.regions_mock.create.assert_called_with(**kwargs)
+        self.identity_sdk_client.create_region.assert_called_with(**kwargs)
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.datalist, data)
 
     def test_region_create_no_options(self):
         arglist = [
-            identity_fakes.region_id,
+            self.region.id,
         ]
         verifylist = [
-            ('region', identity_fakes.region_id),
+            ('region', self.region.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -96,23 +85,23 @@ class TestRegionCreate(TestRegion):
         # Set expected values
         kwargs = {
             'description': None,
-            'id': identity_fakes.region_id,
-            'parent_region': None,
+            'id': self.region.id,
+            'parent_region_id': None,
         }
-        self.regions_mock.create.assert_called_with(**kwargs)
+        self.identity_sdk_client.create_region.assert_called_with(**kwargs)
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.datalist, data)
 
     def test_region_create_parent_region_id(self):
         arglist = [
-            identity_fakes.region_id,
+            self.region.id,
             '--parent-region',
-            identity_fakes.region_parent_region_id,
+            self.region.parent_region_id,
         ]
         verifylist = [
-            ('region', identity_fakes.region_id),
-            ('parent_region', identity_fakes.region_parent_region_id),
+            ('region', self.region.id),
+            ('parent_region', self.region.parent_region_id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -124,41 +113,43 @@ class TestRegionCreate(TestRegion):
         # Set expected values
         kwargs = {
             'description': None,
-            'id': identity_fakes.region_id,
-            'parent_region': identity_fakes.region_parent_region_id,
+            'id': self.region.id,
+            'parent_region_id': self.region.parent_region_id,
         }
-        self.regions_mock.create.assert_called_with(**kwargs)
+        self.identity_sdk_client.create_region.assert_called_with(**kwargs)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.datalist, data)
 
 
-class TestRegionDelete(TestRegion):
+class TestRegionDelete(identity_fakes.TestIdentityv3):
     def setUp(self):
         super().setUp()
 
-        self.regions_mock.delete.return_value = None
+        self.region = sdk_fakes.generate_fake_resource(_region.Region)
+        self.identity_sdk_client.delete_region.return_value = None
 
         # Get the command object to test
         self.cmd = region.DeleteRegion(self.app, None)
 
     def test_region_delete_no_options(self):
         arglist = [
-            identity_fakes.region_id,
+            self.region.id,
         ]
         verifylist = [
-            ('region', [identity_fakes.region_id]),
+            ('region', [self.region.id]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.regions_mock.delete.assert_called_with(
-            identity_fakes.region_id,
+        self.identity_sdk_client.delete_region.assert_called_with(
+            self.region.id,
         )
         self.assertIsNone(result)
 
 
-class TestRegionList(TestRegion):
+class TestRegionList(identity_fakes.TestIdentityv3):
+    region = sdk_fakes.generate_fake_resource(_region.Region)
     columns = (
         'Region',
         'Parent Region',
@@ -166,22 +157,16 @@ class TestRegionList(TestRegion):
     )
     datalist = (
         (
-            identity_fakes.region_id,
-            identity_fakes.region_parent_region_id,
-            identity_fakes.region_description,
+            region.id,
+            region.parent_region_id,
+            region.description,
         ),
     )
 
     def setUp(self):
         super().setUp()
 
-        self.regions_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.REGION),
-                loaded=True,
-            ),
-        ]
+        self.identity_sdk_client.regions.return_value = [self.region]
 
         # Get the command object to test
         self.cmd = region.ListRegion(self.app, None)
@@ -195,7 +180,7 @@ class TestRegionList(TestRegion):
         # returns a tuple containing the column names and an iterable
         # containing the data to be listed.
         columns, data = self.cmd.take_action(parsed_args)
-        self.regions_mock.list.assert_called_with()
+        self.identity_sdk_client.regions.assert_called_with()
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.datalist, tuple(data))
@@ -203,10 +188,10 @@ class TestRegionList(TestRegion):
     def test_region_list_parent_region_id(self):
         arglist = [
             '--parent-region',
-            identity_fakes.region_parent_region_id,
+            self.region.parent_region_id,
         ]
         verifylist = [
-            ('parent_region', identity_fakes.region_parent_region_id),
+            ('parent_region', self.region.parent_region_id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -214,41 +199,37 @@ class TestRegionList(TestRegion):
         # returns a tuple containing the column names and an iterable
         # containing the data to be listed.
         columns, data = self.cmd.take_action(parsed_args)
-        self.regions_mock.list.assert_called_with(
-            parent_region_id=identity_fakes.region_parent_region_id
+        self.identity_sdk_client.regions.assert_called_with(
+            parent_region_id=self.region.parent_region_id
         )
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.datalist, tuple(data))
 
 
-class TestRegionSet(TestRegion):
+class TestRegionSet(identity_fakes.TestIdentityv3):
     def setUp(self):
         super().setUp()
 
-        self.regions_mock.update.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.REGION),
-            loaded=True,
-        )
+        self.region = sdk_fakes.generate_fake_resource(_region.Region)
 
         # Get the command object to test
         self.cmd = region.SetRegion(self.app, None)
 
     def test_region_set_no_options(self):
         arglist = [
-            identity_fakes.region_id,
+            self.region.id,
         ]
         verifylist = [
-            ('region', identity_fakes.region_id),
+            ('region', self.region.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
         kwargs = {}
-        self.regions_mock.update.assert_called_with(
-            identity_fakes.region_id, **kwargs
+        self.identity_sdk_client.update_region.assert_called_with(
+            self.region.id, **kwargs
         )
         self.assertIsNone(result)
 
@@ -256,11 +237,11 @@ class TestRegionSet(TestRegion):
         arglist = [
             '--description',
             'qwerty',
-            identity_fakes.region_id,
+            self.region.id,
         ]
         verifylist = [
             ('description', 'qwerty'),
-            ('region', identity_fakes.region_id),
+            ('region', self.region.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -270,8 +251,8 @@ class TestRegionSet(TestRegion):
         kwargs = {
             'description': 'qwerty',
         }
-        self.regions_mock.update.assert_called_with(
-            identity_fakes.region_id, **kwargs
+        self.identity_sdk_client.update_region.assert_called_with(
+            self.region.id, **kwargs
         )
         self.assertIsNone(result)
 
@@ -279,11 +260,11 @@ class TestRegionSet(TestRegion):
         arglist = [
             '--parent-region',
             'new_parent',
-            identity_fakes.region_id,
+            self.region.id,
         ]
         verifylist = [
             ('parent_region', 'new_parent'),
-            ('region', identity_fakes.region_id),
+            ('region', self.region.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -291,33 +272,30 @@ class TestRegionSet(TestRegion):
 
         # Set expected values
         kwargs = {
-            'parent_region': 'new_parent',
+            'parent_region_id': 'new_parent',
         }
-        self.regions_mock.update.assert_called_with(
-            identity_fakes.region_id, **kwargs
+        self.identity_sdk_client.update_region.assert_called_with(
+            self.region.id, **kwargs
         )
         self.assertIsNone(result)
 
 
-class TestRegionShow(TestRegion):
+class TestRegionShow(identity_fakes.TestIdentityv3):
     def setUp(self):
         super().setUp()
 
-        self.regions_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.REGION),
-            loaded=True,
-        )
+        self.region = sdk_fakes.generate_fake_resource(_region.Region)
+        self.identity_sdk_client.get_region.return_value = self.region
 
         # Get the command object to test
         self.cmd = region.ShowRegion(self.app, None)
 
     def test_region_show(self):
         arglist = [
-            identity_fakes.region_id,
+            self.region.id,
         ]
         verifylist = [
-            ('region', identity_fakes.region_id),
+            ('region', self.region.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -325,15 +303,15 @@ class TestRegionShow(TestRegion):
         # returns a two-part tuple with a tuple of column names and a tuple of
         # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
-        self.regions_mock.get.assert_called_with(
-            identity_fakes.region_id,
+        self.identity_sdk_client.get_region.assert_called_with(
+            self.region.id,
         )
 
-        collist = ('description', 'parent_region', 'region')
+        collist = ('region', 'description', 'parent_region')
         self.assertEqual(collist, columns)
         datalist = (
-            identity_fakes.region_description,
-            identity_fakes.region_parent_region_id,
-            identity_fakes.region_id,
+            self.region.id,
+            self.region.description,
+            self.region.parent_region_id,
         )
         self.assertEqual(datalist, data)