Add group functional tests

Adds functional tests for groups. For now, the tests are created under
a single class. Once we have a gate that runs against LDAP,
we will create a class that only contains readonly tests and
a tox call for it (e.g tox -e functional-readonly).

Change-Id: Ib1db14367b8dc3bd6356aff0dfef1fc573211c6e

keystoneclient/tests/functional/v3/test_groups.py

@@ -0,0 +1,94 @@
+# 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 keystoneauth1.exceptions import http
+from keystoneclient.tests.functional import base
+from keystoneclient.tests.functional.v3 import client_fixtures as fixtures
+
+
+class GroupsTestCase(base.V3ClientTestCase):
+
+    def check_group(self, group, group_ref=None):
+        self.assertIsNotNone(group.id)
+        self.assertIn('self', group.links)
+        self.assertIn('/groups/' + group.id, group.links['self'])
+
+        if group_ref:
+            self.assertEqual(group_ref['name'], group.name)
+            self.assertEqual(group_ref['domain'], group.domain_id)
+
+            # There is no guarantee description is present in group
+            if hasattr(group_ref, 'description'):
+                self.assertEqual(group_ref['description'], group.description)
+
+        else:
+            # Only check remaining mandatory attributes
+            self.assertIsNotNone(group.name)
+            self.assertIsNotNone(group.domain_id)
+
+    def test_create_group(self):
+        group_ref = {
+            'name': fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex,
+            'domain': self.project_domain_id,
+            'description': uuid.uuid4().hex}
+
+        group = self.client.groups.create(**group_ref)
+        self.addCleanup(self.client.groups.delete, group)
+        self.check_group(group, group_ref)
+
+    def test_get_group(self):
+        group = fixtures.Group(self.client, self.project_domain_id)
+        self.useFixture(group)
+
+        group_ret = self.client.groups.get(group.id)
+        self.check_group(group_ret, group.ref)
+
+    def test_list_groups(self):
+        group_one = fixtures.Group(self.client, self.project_domain_id)
+        self.useFixture(group_one)
+
+        group_two = fixtures.Group(self.client, self.project_domain_id)
+        self.useFixture(group_two)
+
+        groups = self.client.groups.list()
+
+        # All groups are valid
+        for group in groups:
+            self.check_group(group)
+
+        self.assertIn(group_one.entity, groups)
+        self.assertIn(group_two.entity, groups)
+
+    def test_update_group(self):
+        group = fixtures.Group(self.client, self.project_domain_id)
+        self.useFixture(group)
+
+        new_name = fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex
+        new_description = uuid.uuid4().hex
+
+        group_ret = self.client.groups.update(group.id,
+                                              name=new_name,
+                                              description=new_description)
+
+        group.ref.update({'name': new_name, 'description': new_description})
+        self.check_group(group_ret, group.ref)
+
+    def test_delete_group(self):
+        group = self.client.groups.create(name=uuid.uuid4().hex,
+                                          domain=self.project_domain_id)
+
+        self.client.groups.delete(group.id)
+        self.assertRaises(http.NotFound,
+                          self.client.groups.get,
+                          group.id)