From d38af94bed473595155852f499c6aa56c5a33649 Mon Sep 17 00:00:00 2001 From: David Shrewsbury Date: Tue, 8 Dec 2015 15:18:27 -0500 Subject: [PATCH] Bug fix: Allow name update for domains We were not passing the 'name' argument through to the client for updating a domain. Fix that and add tests to verify it is passed. Also add missing domain API unit tests. Change-Id: I62a7d6de0a4890ca9f58aaa3de5090e395baf850 --- .../fix-update-domain-af47b066ac52eb7f.yaml | 3 + shade/operatorcloud.py | 3 +- shade/tests/functional/test_domain.py | 12 ++++ shade/tests/unit/test_domains.py | 64 +++++++++++++++++++ 4 files changed, 81 insertions(+), 1 deletion(-) create mode 100644 releasenotes/notes/fix-update-domain-af47b066ac52eb7f.yaml diff --git a/releasenotes/notes/fix-update-domain-af47b066ac52eb7f.yaml b/releasenotes/notes/fix-update-domain-af47b066ac52eb7f.yaml new file mode 100644 index 000000000..060461d09 --- /dev/null +++ b/releasenotes/notes/fix-update-domain-af47b066ac52eb7f.yaml @@ -0,0 +1,3 @@ +--- +fixes: + - Fix for update_domain() where 'name' was not updatable. diff --git a/shade/operatorcloud.py b/shade/operatorcloud.py index 0ee183a2a..2d80d1153 100644 --- a/shade/operatorcloud.py +++ b/shade/operatorcloud.py @@ -1030,7 +1030,8 @@ class OperatorCloud(openstackcloud.OpenStackCloud): with _utils.shade_exceptions( "Error in updating domain {domain}".format(domain=domain_id)): domain = self.manager.submitTask(_tasks.DomainUpdate( - domain=domain_id, description=description, enabled=enabled)) + domain=domain_id, name=name, description=description, + enabled=enabled)) return _utils.normalize_domains([domain])[0] def delete_domain(self, domain_id): diff --git a/shade/tests/functional/test_domain.py b/shade/tests/functional/test_domain.py index 954348a89..dcb496bdb 100644 --- a/shade/tests/functional/test_domain.py +++ b/shade/tests/functional/test_domain.py @@ -63,3 +63,15 @@ class TestDomain(base.TestCase): results = self.cloud.search_domains(filters=dict(name=domain_name)) self.assertEqual(1, len(results)) self.assertEqual(domain_name, results[0]['name']) + + def test_update_domain(self): + domain = self.cloud.create_domain(self.domain_prefix, 'description') + self.assertEqual(self.domain_prefix, domain['name']) + self.assertEqual('description', domain['description']) + self.assertTrue(domain['enabled']) + updated = self.cloud.update_domain(domain['id'], name='updated name', + description='updated description', + enabled=False) + self.assertEqual('updated name', updated['name']) + self.assertEqual('updated description', updated['description']) + self.assertFalse(updated['enabled']) diff --git a/shade/tests/unit/test_domains.py b/shade/tests/unit/test_domains.py index a016d0732..fe72a0183 100644 --- a/shade/tests/unit/test_domains.py +++ b/shade/tests/unit/test_domains.py @@ -14,8 +14,10 @@ # limitations under the License. import mock +import testtools import shade +from shade import meta from shade.tests.unit import base from shade.tests import fakes @@ -46,3 +48,65 @@ class TestDomains(base.TestCase): self.assertFalse(mock_keystone.domains.list.called) self.assertTrue(mock_keystone.domains.get.called) self.assertEqual(domain['name'], 'a-domain') + + @mock.patch.object(shade._utils, 'normalize_domains') + @mock.patch.object(shade.OpenStackCloud, 'keystone_client') + def test_create_domain(self, mock_keystone, mock_normalize): + mock_keystone.domains.create.return_value = domain_obj + self.cloud.create_domain(domain_obj.name, + domain_obj.description) + mock_keystone.domains.create.assert_called_once_with( + name=domain_obj.name, description=domain_obj.description, + enabled=True) + mock_normalize.assert_called_once_with([meta.obj_to_dict(domain_obj)]) + + @mock.patch.object(shade.OpenStackCloud, 'keystone_client') + def test_create_domain_exception(self, mock_keystone): + mock_keystone.domains.create.side_effect = Exception() + with testtools.ExpectedException( + shade.OpenStackCloudException, + "Failed to create domain domain_name" + ): + self.cloud.create_domain('domain_name') + + @mock.patch.object(shade.OperatorCloud, 'update_domain') + @mock.patch.object(shade.OpenStackCloud, 'keystone_client') + def test_delete_domain(self, mock_keystone, mock_update): + mock_update.return_value = dict(id='update_domain_id') + self.cloud.delete_domain('domain_id') + mock_update.assert_called_once_with('domain_id', enabled=False) + mock_keystone.domains.delete.assert_called_once_with( + domain='update_domain_id') + + @mock.patch.object(shade.OperatorCloud, 'update_domain') + @mock.patch.object(shade.OpenStackCloud, 'keystone_client') + def test_delete_domain_exception(self, mock_keystone, mock_update): + mock_keystone.domains.delete.side_effect = Exception() + with testtools.ExpectedException( + shade.OpenStackCloudException, + "Failed to delete domain domain_id" + ): + self.cloud.delete_domain('domain_id') + + @mock.patch.object(shade._utils, 'normalize_domains') + @mock.patch.object(shade.OpenStackCloud, 'keystone_client') + def test_update_domain(self, mock_keystone, mock_normalize): + mock_keystone.domains.update.return_value = domain_obj + self.cloud.update_domain('domain_id', + name='new name', + description='new description', + enabled=False) + mock_keystone.domains.update.assert_called_once_with( + domain='domain_id', name='new name', + description='new description', enabled=False) + mock_normalize.assert_called_once_with( + [meta.obj_to_dict(domain_obj)]) + + @mock.patch.object(shade.OpenStackCloud, 'keystone_client') + def test_update_domain_exception(self, mock_keystone): + mock_keystone.domains.update.side_effect = Exception() + with testtools.ExpectedException( + shade.OpenStackCloudException, + "Error in updating domain domain_id" + ): + self.cloud.delete_domain('domain_id')