def test_list_projects(self):
write_test_data()
session = connection.get_session()
project_api = ProjectApi(session)
projects = project_api.list_projects()
assert len(projects) == 4
assert projects[0].get("id") == "1"
def test_bind_role_to_group(self):
write_domain_data()
write_project_data()
write_group_data()
write_user_data()
write_role_data()
session = connection.get_session()
relationship_api = RelationshipApi(session)
for rgm in get_group_role_membership():
role_id = rgm.to_dict().get("role_id")
group_id = rgm.to_dict().get("group_id")
relationship_api.bind_role_to_group(role_id, group_id)
try:
for rgm in get_group_role_membership():
role_id = rgm.to_dict().get("role_id")
group_id = rgm.to_dict().get("group_id")
relationship_api.bind_role_to_group(role_id, group_id)
except exception.Conflict as e:
assert isinstance(e, exception.Conflict)
else:
raise Exception("Conflict didn't happen")
grms = session.query(default_model.GroupRoleMembership).all()
assert len(grms) == 5
def write_group_role_membership():
session = connection.get_session()
grms = get_group_role_membership()
with session.begin():
for g in grms:
session.add(g)
session.flush()
return session
def write_user_role_membership():
session = connection.get_session()
urms = get_user_role_membership()
with session.begin():
for u in urms:
session.add(u)
session.flush()
return session
def write_role_data():
session = connection.get_session()
roles = get_role_data()
with session.begin():
for role in roles:
session.add(role)
session.flush()
return session
def write_user_data():
session = connection.get_session()
users = get_user_data()
with session.begin():
for user in users:
session.add(user)
session.flush()
return session
def write_group_data():
session = connection.get_session()
groups = get_group_data()
with session.begin():
for group in groups:
session.add(group)
session.flush()
return session
def write_domain_data():
session = connection.get_session()
domains = get_domain_data()
with session.begin():
for domain in domains:
session.add(domain)
session.flush()
return session
def write_project_data():
session = connection.get_session()
projects = get_project_data()
with session.begin():
for project in projects:
session.add(project)
session.flush()
return session
def test_update_project(self):
write_test_data()
session = connection.get_session()
project_api = ProjectApi(session)
project = {"extra": '{"test": "test_project2_update_project"}', "main": "test"}
project_api.update_project(project_id="1", project=project)
ref = project_api.get_project(project_id="1")
assert ref.get("extra").get("main") == "test"
def test_list_groups_for_domain(self):
write_domain_data()
write_group_data()
session = connection.get_session()
domain_id = "1"
domain_api = DomainApi(session)
groups = domain_api.list_groups_for_domain(domain_id)
assert len(groups) == 2
def test_list_projects_for_domain(self):
write_domain_data()
write_project_data()
session = connection.get_session()
domain_id = "1"
domain_api = DomainApi(session)
projects = domain_api.list_projects_for_domain(domain_id)
assert len(projects) == 2
def test_update_project_conflict(self):
write_test_data()
session = connection.get_session()
project_api = ProjectApi(session)
project = {"name": "test_project2"}
try:
project_api.update_project(project_id="1", project=project)
except Exception as e:
assert isinstance(e, exception.Conflict)
def test_create_domains(self):
session = connection.get_session()
domain_api = DomainApi(session)
for domain in get_domain_data():
domain = domain.to_dict()
domain_api.create_domain(domain)
result = domain_api.list_domains()
assert isinstance(result, list)
assert len(result) == 4
def test_list_groups(self):
session = connection.get_session()
group_api = GroupApi(session)
groups = group_api.list_groups()
assert len(groups) == 0
write_test_data()
groups = group_api.list_groups()
assert len(groups) == 2
def test_update_domain(self):
session = connection.get_session()
domain_api = DomainApi(session)
for domain in get_domain_data():
domain = domain.to_dict()
domain_api.create_domain(domain)
domain = {"name": "test_domain4_update", "enabled": 1}
domain_api.update_domain(domain_id="4", domain=domain)
ref = domain_api.get_domain(domain_id="4")
assert ref.get("name") == "test_domain4_update"
def test_get_role(self):
write_test_data()
session = connection.get_session()
role_api = RoleApi(session)
role = role_api.get_role(role_id="1")
assert role.get("name") == "test_role1"
try:
role = role_api.get_role(role_id="10")
except exception.RoleNotFound as e:
assert isinstance(e, exception.RoleNotFound)
def test_get_user(self):
write_test_data()
session = connection.get_session()
user_api = UserApi(session)
user = user_api.get_user(user_id="1")
assert user.get("name") == "test_user1"
try:
user = user_api.get_user(user_id="10")
except exception.UserNotFound as e:
assert isinstance(e, exception.UserNotFound)
def test_create_project(self):
write_domain_data()
session = connection.get_session()
project_api = ProjectApi(session)
projects = get_project_data()
for project in projects:
project = project.to_dict()
project_api.create_project(project)
refs = project_api.list_projects()
assert len(refs) == 4
assert refs[0].get("id") == "1"
def test_update_domain_conflict(self):
session = connection.get_session()
domain_api = DomainApi(session)
for domain in get_domain_data():
domain = domain.to_dict()
domain_api.create_domain(domain)
domain = {"name": "test_domain3", "enabled": 1}
try:
ref = domain_api.update_domain(domain_id="4", domain=domain)
except Exception as e:
assert isinstance(e, exception.Conflict)
def test_list_users(self):
# test the empty user table
session = connection.get_session()
user_api = UserApi(session)
users = user_api.list_users()
assert isinstance(users, list)
assert len(users) == 0
write_test_data()
users = user_api.list_users()
assert isinstance(users, list)
assert len(users) == 5
def test_create_project_conflict(self):
write_domain_data()
session = connection.get_session()
project_api = ProjectApi(session)
projects = get_project_data()
for project in projects:
project = project.to_dict()
project_api.create_project(project)
try:
project_api.create_project(projects[0].to_dict())
except Exception as e:
assert isinstance(e, exception.Conflict)
def test_create_domain_conflict(self):
session = connection.get_session()
domain_api = DomainApi(session)
for domain in get_domain_data():
domain = domain.to_dict()
domain_api.create_domain(domain)
domain = get_domain_data()[0]
domain = domain.to_dict()
try:
domain_api.create_domain(domain)
except Exception as e:
assert isinstance(e, exception.Conflict)
def test_create_group(self):
write_domain_data()
write_project_data()
groups = get_group_data()
session = connection.get_session()
group_api = GroupApi(session)
for g in groups:
group = g.to_dict()
group_api.create_group(group)
groups = group_api.list_groups()
assert len(groups) == 2
def test_get_group(self):
write_test_data()
session = connection.get_session()
group_api = GroupApi(session)
group = group_api.get_group(group_id="1")
assert group.get("name") == "test_group1"
try:
group = group_api.get_group(group_id="5")
except exception.GroupNotFound as e:
assert isinstance(e, exception.GroupNotFound)
else:
raise Exception("GroupNotFound didn't happen")
def test_update_group(self):
write_test_data()
session = connection.get_session()
group_api = GroupApi(session)
group = {"name": "group_update"}
group_api.update_group("2", group)
g = group_api.get_group("2")
assert g.get("name") == "group_update"
try:
group = {"name": "test_group1"}
group_api.update_group("2", group)
except exception.Conflict as e:
assert isinstance(e, exception.Conflict)
else:
raise Exception("Conflict didn't happen")
def test_update_role(self):
write_test_data()
session = connection.get_session()
role_api = RoleApi(session)
role = {"name": "test_role1_update"}
role_api.update_role("1", role)
role = role_api.get_role("1")
assert role.get("name") == "test_role1_update"
try:
role = {"name": "test_role2"}
role_api.update_role("1", role)
except exception.Conflict as e:
assert isinstance(e, exception.Conflict)
else:
raise Exception("Conflict didn't happen")
def test_update_user(self):
write_test_data()
session = connection.get_session()
user_api = UserApi(session)
user = {"name": "test_user20"}
user_api.update_user(user_id="2", user=user)
u = user_api.get_user(user_id="2")
assert u.get("name") == "test_user20"
user = {"name": "test_user3"}
try:
user_api.update_user(user_id="1", user=user)
except exception.Conflict as e:
assert isinstance(e, exception.Conflict)
else:
raise Exception("Conflict didn't happen")
def test_create_role(self):
write_domain_data()
write_project_data()
write_group_data()
write_user_data()
session = connection.get_session()
role_api = RoleApi(session)
roles = role_api.list_roles()
assert len(roles) == 0
roles = get_role_data()
for r in roles:
role = r.to_dict()
role_api.create_role(role)
roles = role_api.list_roles()
assert len(roles) == 3
def test_create_user(self):
write_domain_data()
write_project_data()
session = connection.get_session()
user_api = UserApi(session)
for user in get_user_data():
user = user.to_dict()
user_api.create_user(user)
users = user_api.list_users()
assert len(users) == 5
for user in get_user_data():
try:
user = user.to_dict()
user_api.create_user(user)
except Exception as e:
assert isinstance(e, exception.Conflict)
