470 lines
17 KiB
Python
470 lines
17 KiB
Python
# 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 import exceptions
|
|
from keystoneclient.tests.functional import base
|
|
from keystoneclient.tests.functional.v3 import client_fixtures as fixtures
|
|
|
|
|
|
class ProjectsTestMixin(object):
|
|
|
|
def check_project(self, project, project_ref=None):
|
|
self.assertIsNotNone(project.id)
|
|
self.assertIn('self', project.links)
|
|
self.assertIn('/projects/' + project.id, project.links['self'])
|
|
|
|
if project_ref:
|
|
self.assertEqual(project_ref['name'], project.name)
|
|
self.assertEqual(project_ref['domain'], project.domain_id)
|
|
self.assertEqual(project_ref['enabled'], project.enabled)
|
|
|
|
# There is no guarantee the attributes below are present in project
|
|
if hasattr(project_ref, 'description'):
|
|
self.assertEqual(project_ref['description'],
|
|
project.description)
|
|
if hasattr(project_ref, 'parent'):
|
|
self.assertEqual(project_ref['parent'], project.parent)
|
|
|
|
else:
|
|
# Only check remaining mandatory attributes
|
|
self.assertIsNotNone(project.name)
|
|
self.assertIsNotNone(project.domain_id)
|
|
self.assertIsNotNone(project.enabled)
|
|
|
|
|
|
class ProjectsTestCase(base.V3ClientTestCase, ProjectsTestMixin):
|
|
|
|
def setUp(self):
|
|
super(ProjectsTestCase, self).setUp()
|
|
self.test_domain = fixtures.Domain(self.client)
|
|
self.useFixture(self.test_domain)
|
|
|
|
self.test_project = fixtures.Project(self.client, self.test_domain.id)
|
|
self.useFixture(self.test_project)
|
|
self.special_tag = '~`!@#$%^&*()-_+=<>.? \'"'
|
|
|
|
def test_create_subproject(self):
|
|
project_ref = {
|
|
'name': fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex,
|
|
'domain': self.test_domain.id,
|
|
'enabled': True,
|
|
'description': uuid.uuid4().hex,
|
|
'parent': self.test_project.id}
|
|
|
|
project = self.client.projects.create(**project_ref)
|
|
self.addCleanup(self.client.projects.delete, project)
|
|
self.check_project(project, project_ref)
|
|
|
|
def test_create_project(self):
|
|
project_ref = {
|
|
'name': fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex,
|
|
'domain': self.test_domain.id,
|
|
'enabled': True,
|
|
'description': uuid.uuid4().hex}
|
|
|
|
project = self.client.projects.create(**project_ref)
|
|
self.addCleanup(self.client.projects.delete, project)
|
|
self.check_project(project, project_ref)
|
|
|
|
def test_get_project(self):
|
|
project_ret = self.client.projects.get(self.test_project.id)
|
|
self.check_project(project_ret, self.test_project.ref)
|
|
|
|
def test_get_project_invalid_params(self):
|
|
self.assertRaises(exceptions.ValidationError,
|
|
self.client.projects.get,
|
|
self.test_project.id,
|
|
subtree_as_list=True, subtree_as_ids=True)
|
|
self.assertRaises(exceptions.ValidationError,
|
|
self.client.projects.get,
|
|
self.test_project.id,
|
|
parents_as_list=True, parents_as_ids=True)
|
|
|
|
def test_get_hierarchy_as_list(self):
|
|
project = fixtures.Project(self.client, self.test_domain.id,
|
|
parent=self.test_project.id)
|
|
self.useFixture(project)
|
|
|
|
child_project = fixtures.Project(self.client, self.test_domain.id,
|
|
parent=project.id)
|
|
self.useFixture(child_project)
|
|
|
|
# Only parents and subprojects that the current user has role
|
|
# assingments on are returned when asked for subtree_as_list and
|
|
# parents_as_list.
|
|
role = fixtures.Role(self.client)
|
|
self.useFixture(role)
|
|
self.client.roles.grant(role.id, user=self.user_id,
|
|
project=self.test_project.id)
|
|
self.client.roles.grant(role.id, user=self.user_id,
|
|
project=project.id)
|
|
self.client.roles.grant(role.id, user=self.user_id,
|
|
project=child_project.id)
|
|
|
|
project_ret = self.client.projects.get(project.id,
|
|
subtree_as_list=True,
|
|
parents_as_list=True)
|
|
|
|
self.check_project(project_ret, project.ref)
|
|
self.assertItemsEqual(
|
|
[{'project': self.test_project.entity.to_dict()}],
|
|
project_ret.parents)
|
|
self.assertItemsEqual(
|
|
[{'project': child_project.entity.to_dict()}],
|
|
project_ret.subtree)
|
|
|
|
def test_get_hierarchy_as_ids(self):
|
|
project = fixtures.Project(self.client, self.test_domain.id,
|
|
parent=self.test_project.id)
|
|
self.useFixture(project)
|
|
|
|
child_project = fixtures.Project(self.client, self.test_domain.id,
|
|
parent=project.id)
|
|
self.useFixture(child_project)
|
|
|
|
project_ret = self.client.projects.get(project.id,
|
|
subtree_as_ids=True,
|
|
parents_as_ids=True)
|
|
|
|
self.assertItemsEqual([self.test_project.id], project_ret.parents)
|
|
self.assertItemsEqual([child_project.id], project_ret.subtree)
|
|
|
|
def test_list_projects(self):
|
|
project_one = fixtures.Project(self.client, self.test_domain.id)
|
|
self.useFixture(project_one)
|
|
|
|
project_two = fixtures.Project(self.client, self.test_domain.id)
|
|
self.useFixture(project_two)
|
|
|
|
projects = self.client.projects.list()
|
|
|
|
# All projects are valid
|
|
for project in projects:
|
|
self.check_project(project)
|
|
|
|
self.assertIn(project_one.entity, projects)
|
|
self.assertIn(project_two.entity, projects)
|
|
|
|
def test_list_subprojects(self):
|
|
parent_project = fixtures.Project(self.client, self.test_domain.id)
|
|
self.useFixture(parent_project)
|
|
|
|
child_project_one = fixtures.Project(self.client, self.test_domain.id,
|
|
parent=parent_project.id)
|
|
self.useFixture(child_project_one)
|
|
|
|
child_project_two = fixtures.Project(self.client, self.test_domain.id,
|
|
parent=parent_project.id)
|
|
self.useFixture(child_project_two)
|
|
|
|
projects = self.client.projects.list(parent=parent_project.id)
|
|
|
|
# All projects are valid
|
|
for project in projects:
|
|
self.check_project(project)
|
|
|
|
self.assertIn(child_project_one.entity, projects)
|
|
self.assertIn(child_project_two.entity, projects)
|
|
|
|
# Parent project should not be included in the result
|
|
self.assertNotIn(parent_project.entity, projects)
|
|
|
|
def test_update_project(self):
|
|
project = fixtures.Project(self.client, self.test_domain.id)
|
|
self.useFixture(project)
|
|
|
|
new_name = fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex
|
|
new_description = uuid.uuid4().hex
|
|
project_ret = self.client.projects.update(project.id,
|
|
name=new_name,
|
|
enabled=False,
|
|
description=new_description)
|
|
|
|
project.ref.update({'name': new_name, 'enabled': False,
|
|
'description': new_description})
|
|
self.check_project(project_ret, project.ref)
|
|
|
|
def test_update_project_domain_not_allowed(self):
|
|
domain = fixtures.Domain(self.client)
|
|
self.useFixture(domain)
|
|
# Cannot update domain after project is created.
|
|
self.assertRaises(http.BadRequest,
|
|
self.client.projects.update,
|
|
self.test_project.id, domain=domain.id)
|
|
|
|
def test_delete_project(self):
|
|
project = self.client.projects.create(name=uuid.uuid4().hex,
|
|
domain=self.test_domain.id,
|
|
enabled=True)
|
|
|
|
self.client.projects.delete(project.id)
|
|
self.assertRaises(http.NotFound,
|
|
self.client.projects.get,
|
|
project.id)
|
|
|
|
def test_list_projects_with_tag_filters(self):
|
|
project_one = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=['tag1'])
|
|
project_two = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=['tag1', 'tag2'])
|
|
project_three = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=['tag2', 'tag3'])
|
|
|
|
self.useFixture(project_one)
|
|
self.useFixture(project_two)
|
|
self.useFixture(project_three)
|
|
|
|
projects = self.client.projects.list(tags='tag1')
|
|
project_ids = []
|
|
for project in projects:
|
|
project_ids.append(project.id)
|
|
self.assertIn(project_one.id, project_ids)
|
|
|
|
projects = self.client.projects.list(tags_any='tag1')
|
|
project_ids = []
|
|
for project in projects:
|
|
project_ids.append(project.id)
|
|
self.assertIn(project_one.id, project_ids)
|
|
self.assertIn(project_two.id, project_ids)
|
|
|
|
projects = self.client.projects.list(not_tags='tag1')
|
|
project_ids = []
|
|
for project in projects:
|
|
project_ids.append(project.id)
|
|
self.assertNotIn(project_one.id, project_ids)
|
|
|
|
projects = self.client.projects.list(not_tags_any='tag1,tag2')
|
|
project_ids = []
|
|
for project in projects:
|
|
project_ids.append(project.id)
|
|
self.assertNotIn(project_one.id, project_ids)
|
|
self.assertNotIn(project_two.id, project_ids)
|
|
self.assertNotIn(project_three.id, project_ids)
|
|
|
|
projects = self.client.projects.list(tags='tag1,tag2')
|
|
project_ids = []
|
|
for project in projects:
|
|
project_ids.append(project.id)
|
|
self.assertNotIn(project_one.id, project_ids)
|
|
self.assertIn(project_two.id, project_ids)
|
|
self.assertNotIn(project_three.id, project_ids)
|
|
|
|
def test_add_tag(self):
|
|
project = fixtures.Project(self.client, self.test_domain.id)
|
|
self.useFixture(project)
|
|
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertEqual([], tags)
|
|
|
|
project.add_tag('tag1')
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertEqual(['tag1'], tags)
|
|
|
|
# verify there is an error when you try to add the same tag
|
|
self.assertRaises(http.BadRequest,
|
|
project.add_tag,
|
|
'tag1')
|
|
|
|
def test_update_tags(self):
|
|
project = fixtures.Project(self.client, self.test_domain.id)
|
|
self.useFixture(project)
|
|
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertEqual([], tags)
|
|
|
|
project.update_tags(['tag1', 'tag2', self.special_tag])
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertIn('tag1', tags)
|
|
self.assertIn('tag2', tags)
|
|
self.assertIn(self.special_tag, tags)
|
|
self.assertEqual(3, len(tags))
|
|
|
|
project.update_tags([])
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertEqual([], tags)
|
|
|
|
# cannot have duplicate tags in update
|
|
self.assertRaises(http.BadRequest,
|
|
project.update_tags,
|
|
['tag1', 'tag1'])
|
|
|
|
def test_delete_tag(self):
|
|
project = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=['tag1', self.special_tag])
|
|
self.useFixture(project)
|
|
|
|
project.delete_tag('tag1')
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertEqual([self.special_tag], tags)
|
|
|
|
project.delete_tag(self.special_tag)
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertEqual([], tags)
|
|
|
|
def test_delete_all_tags(self):
|
|
project_one = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=['tag1'])
|
|
|
|
project_two = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=['tag1', 'tag2', self.special_tag])
|
|
|
|
project_three = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=[])
|
|
|
|
self.useFixture(project_one)
|
|
self.useFixture(project_two)
|
|
self.useFixture(project_three)
|
|
|
|
result_one = project_one.delete_all_tags()
|
|
tags_one = self.client.projects.get(project_one.id).tags
|
|
tags_two = self.client.projects.get(project_two.id).tags
|
|
self.assertEqual([], result_one)
|
|
self.assertEqual([], tags_one)
|
|
self.assertIn('tag1', tags_two)
|
|
|
|
result_two = project_two.delete_all_tags()
|
|
tags_two = self.client.projects.get(project_two.id).tags
|
|
self.assertEqual([], result_two)
|
|
self.assertEqual([], tags_two)
|
|
|
|
result_three = project_three.delete_all_tags()
|
|
tags_three = self.client.projects.get(project_three.id).tags
|
|
self.assertEqual([], result_three)
|
|
self.assertEqual([], tags_three)
|
|
|
|
def test_list_tags(self):
|
|
tags_one = ['tag1']
|
|
project_one = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=tags_one)
|
|
|
|
tags_two = ['tag1', 'tag2']
|
|
project_two = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=tags_two)
|
|
|
|
tags_three = []
|
|
project_three = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=tags_three)
|
|
|
|
self.useFixture(project_one)
|
|
self.useFixture(project_two)
|
|
self.useFixture(project_three)
|
|
|
|
result_one = project_one.list_tags()
|
|
result_two = project_two.list_tags()
|
|
result_three = project_three.list_tags()
|
|
|
|
for tag in tags_one:
|
|
self.assertIn(tag, result_one)
|
|
self.assertEqual(1, len(result_one))
|
|
|
|
for tag in tags_two:
|
|
self.assertIn(tag, result_two)
|
|
self.assertEqual(2, len(result_two))
|
|
|
|
for tag in tags_three:
|
|
self.assertIn(tag, result_three)
|
|
self.assertEqual(0, len(result_three))
|
|
|
|
def test_check_tag(self):
|
|
project = fixtures.Project(
|
|
self.client, self.test_domain.id,
|
|
tags=['tag1'])
|
|
self.useFixture(project)
|
|
|
|
tags = self.client.projects.get(project.id).tags
|
|
self.assertEqual(['tag1'], tags)
|
|
self.assertTrue(project.check_tag('tag1'))
|
|
self.assertFalse(project.check_tag('tag2'))
|
|
self.assertFalse(project.check_tag(self.special_tag))
|
|
|
|
def test_add_invalid_tags(self):
|
|
project_one = fixtures.Project(
|
|
self.client, self.test_domain.id)
|
|
|
|
self.useFixture(project_one)
|
|
|
|
self.assertRaises(exceptions.BadRequest,
|
|
project_one.add_tag,
|
|
',')
|
|
self.assertRaises(exceptions.BadRequest,
|
|
project_one.add_tag,
|
|
'/')
|
|
self.assertRaises(exceptions.BadRequest,
|
|
project_one.add_tag,
|
|
'')
|
|
|
|
def test_update_invalid_tags(self):
|
|
tags_comma = ['tag1', ',']
|
|
tags_slash = ['tag1', '/']
|
|
tags_blank = ['tag1', '']
|
|
project_one = fixtures.Project(
|
|
self.client, self.test_domain.id)
|
|
|
|
self.useFixture(project_one)
|
|
|
|
self.assertRaises(exceptions.BadRequest,
|
|
project_one.update_tags,
|
|
tags_comma)
|
|
self.assertRaises(exceptions.BadRequest,
|
|
project_one.update_tags,
|
|
tags_slash)
|
|
self.assertRaises(exceptions.BadRequest,
|
|
project_one.update_tags,
|
|
tags_blank)
|
|
|
|
def test_create_project_invalid_tags(self):
|
|
project_ref = {
|
|
'name': fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex,
|
|
'domain': self.test_domain.id,
|
|
'enabled': True,
|
|
'description': uuid.uuid4().hex,
|
|
'tags': ','}
|
|
|
|
self.assertRaises(exceptions.BadRequest,
|
|
self.client.projects.create,
|
|
**project_ref)
|
|
|
|
project_ref = {
|
|
'name': fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex,
|
|
'domain': self.test_domain.id,
|
|
'enabled': True,
|
|
'description': uuid.uuid4().hex,
|
|
'tags': '/'}
|
|
|
|
self.assertRaises(exceptions.BadRequest,
|
|
self.client.projects.create,
|
|
**project_ref)
|
|
|
|
project_ref = {
|
|
'name': fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex,
|
|
'domain': self.test_domain.id,
|
|
'enabled': True,
|
|
'description': uuid.uuid4().hex,
|
|
'tags': ''}
|
|
|
|
self.assertRaises(exceptions.BadRequest,
|
|
self.client.projects.create,
|
|
**project_ref)
|