def test_update_user(self):
group1 = Group("group1")
group2 = Group("group2")
group1.create()
group2.create()
# Create a user
bob = User(self.email,
name="Bob",
role="user",
groups=[group1.group_name])
res2 = bob.create()
self.assertEqual(res2.json()['user']['email'], bob.email)
self.assertEqual(res2.json()['user']['groups'], [group1.group_name])
self.assertEqual(res2.json()["user"]["role"], "user")
# Update the user
res3 = bob.update(name="Bobby",
role="administrator",
groups=[group2.group_name])
self.assertEqual(res3.json()["success"], True)
self.assertEqual(res3.json()['user']['email'], bob.email)
self.assertEqual(res3.json()['user']['name'], bob.name)
self.assertEqual(res3.json()['user']['groups'], [group2.group_name])
self.assertEqual(res3.json()["user"]["role"], "administrator")
# Make sure the user stored in the db is correct
res4 = bob.get()
self.assertEqual(res4.json()['success'], True)
self.assertEqual(res4.json()['user']['email'], bob.email)
self.assertEqual(res4.json()['user']['name'], bob.name)
self.assertEqual(res4.json()['user']['groups'], [group2.group_name])
self.assertEqual(res4.json()['user']['role'], "administrator")
def insert(self, i, texel):
for j1, j2, elem in self.iter():
if isinstance(elem, Empty):
continue
if j1 <= i <= j2:
new = elem.insert(i-j1, texel)
return self.replace(j1, new)
if i == 0: # muss ein Empty auf der ersten Position haben!
return Group([texel, self])
# muss ein empty auf der letzten Position haben
assert i == len(self)
return Group([self, texel])
def test_patch_group_remove_user(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name, users=[bob.email])
res1 = group.create()
res2 = group.update(remove_users=[bob.email])
self.assertEqual(res2.json()['group']['users'], [])
def test_patch_group_add_user(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name)
group.create()
res = group.update(add_users=[bob.email])
self.assertEqual(res.json()['group']['users'], group.users)
def test_15():
"get/set styles"
s0 = defaultstyle
s1 = create_style(bgcolor='red')
t = Characters(text1)
assert t.get_styles(0, len(t)) == [(len(t), s0)]
t = t.set_properties(3, 5, {'bgcolor':'red'})
styles = t.get_styles(0, len(t))
assert styles == [
(3, s0),
(2, s1),
(5, s0),
]
# Styling überschreiben
t = t.set_styles(0, [(len(t), s0)])
assert t.get_styles(0, len(t)) == [(len(t), s0)]
# Und wieder herstellen
t = t.set_styles(0, styles)
styles = t.get_styles(0, len(t))
assert styles == [
(3, s0),
(2, s1),
(5, s0),
]
# Zusammenfassen von Styles:
styles = Group([Characters(text1), Characters(text1)]).get_styles(0, 2*len(text1))
assert len(styles) == 1
assert styles[0][0] == 2*len(text1)
def test_delete_not_used_invitation(self):
recipient = User(self.random_email())
recipient.invite()
sender = User(self.random_email())
sender.create()
invite = Invite(sender.email, recipient.email)
res1 = invite.create()
invite_id = res1.json()["invite"]["id"]
# create a group in minion that includes the recipient (bug#175)
group = Group(self.group_name, users=[recipient.email])
group.create()
# ensure now the recipient is part of the new group
res2 = recipient.get()
self.assertEqual(res2.json()['user']['groups'], [group.group_name])
# also, this user is still marked as "invited"
self.assertEqual(res2.json()['user']['status'], 'invited')
# admin deletes this invitation off minion
res3 = invite.delete(invite_id)
self.assertEqual(res3.json()["success"], True)
# since invitation is gone, user should be gone too
res4 = recipient.get()
self.assertEqual(res4.json()['success'], False)
self.assertEqual(res4.json()['reason'], 'no-such-user')
# recipient is also gone from any group association
res5 = group.get()
self.assertEqual(res5.json()['group']['users'], [])
def test_patch_group_add_site(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name)
res1 = group.create()
res2 = group.update(add_sites=[self.target_url])
self.assertEqual(res2.json()['group']['sites'][0], self.target_url)
def test_decline_invite(self):
recipient = User(self.random_email())
recipient.invite()
sender = User(self.random_email())
sender.create()
invite = Invite(sender.email, recipient.email)
res1 = invite.create()
invite_id = res1.json()["invite"]["id"]
# create a group in minion that includes the recipient (bug#175)
group = Group(self.group_name, users=[recipient.email])
group.create()
# ensure now the recipient is part of the new group
res2 = recipient.get()
self.assertEqual(res2.json()['user']['groups'], [group.group_name])
# recipient has declined the invitation
res3 = invite.update(invite_id, "decline", login=recipient.email)
self.assertEqual(res3.json()['invite']['status'], 'declined')
# when recipient declined, user account is deleted (bug #175)
res4 = recipient.get()
self.assertEqual(res4.json()['success'], False)
self.assertEqual(res4.json()['reason'], 'no-such-user')
# when recipient declined, user is also not part of a group anymore (bug #175)
res5 = group.get()
self.assertEqual(res5.json()['group']['users'], [])
def test_delete_group(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name)
group.create()
res = group.delete()
self.assertEqual(res.json()['success'], True)
def test_get_all_groups(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name)
res1 = group.create()
res2 = Groups().get()
self.assertEqual(res2.json()['groups'][0], res1.json()['group'])
def test_get_group(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name)
group.create()
res = group.get()
self.assertEqual(res.json()['group']['name'], group.group_name)
self.assertEqual(res.json()['group']['description'], group.description)
def test_create_duplicate_group(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name)
group.create()
res = group.create()
self.assertEqual(res.json()['success'], False)
self.assertEqual(res.json()['reason'], 'group-already-exists')
def test_create_duplicate_group(self):
group = Group(self.group_name)
group.create()
# now try to re-create the same leads to duplication error
res = group.create()
self.assertEqual(res.json()['success'], False)
self.assertEqual(res.json()['reason'], 'group-already-exists')
def test_create_group(self):
group = Group(self.group_name, description=self.group_description)
res = group.create()
self.assertEqual(res.json()["success"], True)
self.assertEqual(set(res.json()["group"].keys()),
set(self.expected_inner_keys))
self.assertEqual(res.json()['group']['name'], self.group_name)
self.assertEqual(res.json()['group']['description'],
self.group_description)
def test_patch_group_add_site(self):
group = Group(self.group_name)
res1 = group.create()
self.assertEqual(res1.json()["success"], True)
self.assertEqual(res1.json()["group"]["sites"], [])
res2 = group.update(add_sites=[self.target_url])
self.assertEqual(set(res2.json().keys()), set(res1.json().keys()))
self.assertEqual(set(res2.json()['group'].keys()),
set(res1.json()['group'].keys()))
self.assertEqual(res2.json()['group']['sites'][0], self.target_url)
def test_accept_invite_with_a_different_login_email(self):
# we allow recipient to login with a different email address.
recipient = User(self.random_email())
recipient.invite()
sender = User(self.random_email())
sender.create()
invite = Invite(sender.email, recipient.email)
res1 = invite.create()
invite_id = res1.json()["invite"]["id"]
# create a group and a site and add the recipient to the group
site = Site(self.target_url)
res2 = site.create()
# create a group in minion
group = Group(self.group_name,
sites=[site.url],
users=[recipient.email])
group.create()
# ensure user and site are in this new group
res3 = group.get()
self.assertEqual(res3.json()["group"]["sites"], [site.url])
self.assertEqual(res3.json()["group"]["users"], [recipient.email])
# user should have access to the group and the site
res4 = recipient.get()
self.assertEqual(res4.json()["user"]["sites"], [site.url])
self.assertEqual(res4.json()["user"]["groups"], [group.group_name])
# recipient accepts the invitation with a different login email address
actual_login = self.random_email()
recipient_2 = User(actual_login)
res5 = invite.update(invite_id, "accept", login=recipient_2.email)
self.assertEqual(res5.json()["success"], True)
# upon invitation acceptance, user status changed to active
res6 = recipient_2.get()
self.assertEqual(res6.json()['user']['email'], recipient_2.email)
self.assertEqual(res6.json()['user']['status'], 'active')
# the new email address has access to the group and site
self.assertEqual(res6.json()["user"]["groups"], [group.group_name])
self.assertEqual(res6.json()["user"]["sites"], [site.url])
# if we query the old recipient email, it should not be found
res7 = recipient.get()
self.assertEqual(res7.json()["success"], False)
self.assertEqual(res7.json()["reason"], "no-such-user")
# group should agree that user and site are still member of the group
res8 = group.get()
self.assertEqual(res8.json()["group"]["sites"], [site.url])
self.assertEqual(res8.json()["group"]["users"], [recipient_2.email])
def create_plan(self):
self.plan = Plan(self.TEST_PLAN)
res = self.plan.create()
self.assertEqual(res.json()["success"], True)
self.user = User(self.email)
self.user.create()
self.site = Site(self.target_url, plans=[self.plan.plan["name"]])
self.site.create()
self.group = Group("testgroup",
sites=[self.site.url],
users=[self.user.email])
self.group.create()
def test_create_group_with_existing_user(self):
bob = User(self.email)
bob.create()
alice = User("*****@*****.**")
alice.create()
group = Group(self.group_name, users=[bob.email, alice.email])
res = group.create()
self.assertEqual(res.json()['success'], True)
self.assertEqual(set(res.json()['group']['users']),
set([alice.email, bob.email]))
def test_create_group(self):
bob = User(self.email)
bob.create()
group = Group(self.group_name, description=self.group_description)
res = group.create()
self.assertEqual(set(res.json().keys()), set(["success", "group"]))
self.assertEqual(
set(res.json()["group"].keys()),
set(["id", "created", "name", "description", "users", "sites"]))
self.assertEqual(res.json()['group']['name'], self.group_name)
self.assertEqual(res.json()['group']['description'],
self.group_description)
def test_retrieve_issue_status_and_issues_by_group(self):
# Don't be shock. This test fits here; by querying
# user and group, we should only be given the latest
# issue status.
bob = User(self.email)
bob.create()
group1 = Group("group1", users=[bob.email])
group2 = Group("group2", users=[bob.email])
res1 = group1.create()
res2 = group2.create()
plan = Plan(self.TEST_PLAN)
plan.create()
site1 = Site(self.target_url,
groups=[group1.group_name],
plans=[self.TEST_PLAN["name"]])
site1.create()
site2 = Site(self.target_url,
groups=[group2.group_name],
plans=[self.TEST_PLAN["name"]])
site2.create()
# if we query just test1, should get back only foo.com
report = Reports()
res5 = report.get_status(user=bob.email, group_name=group1.group_name)
r = res5.json()['report']
self.assertEqual(
len(r), 1) # there should just be one dict returned in the list
self.assertEqual(r[0]['target'], site1.url)
# if we try it on get_report_issues we should see similar result
res6 = report.get_issues(user=bob.email, group_name=group1.group_name)
r = res6.json()['report']
self.assertEqual(
len(r), 1) # there should just be one dict returned in the list
self.assertEqual(r[0]['target'], site1.url)
def test_00():
"remove w. simplify"
t2 = TextModel(text2)
for i in range(len(text1)):
t = TextModel(text1)
t.remove(i, i+1)
assert isinstance(t.texel, Characters)
for i in range(len(text1)):
t = TextModel(text1)
t.texel = Group([t.texel])
t.remove(i, i+1)
assert isinstance(t.texel, Characters)
# Die Gruppe wird immer aufgelöst, wenn nur ein Element enthalten
# ist
for i in range(len(text1)):
t = TextModel(text1)
t.texel = Group([t.texel])
t.remove(i, i+1)
assert isinstance(t.texel, Characters)
# Characters it unterschiedlicher Formatierung können nicht
# zusammengefasst werden
for i in range(2*len(text1)):
t = TextModel(text1)
t1 = TextModel(text1, fontsize=20)
t.insert(len(t), t1)
t.remove(i, i+1)
assert isinstance(t.texel, Group)
assert len(t.texel.data) == 2
assert isinstance(t.texel.data[0], Characters)
assert isinstance(t.texel.data[1], Characters)
text = '01234567890123456789'
text = text[:i]+text[i+1:]
assert t.get_text() == text
def test_get_group(self):
user = User(self.email)
user.create()
group = Group(self.group_name,
description=self.group_description,
users=[user.email])
res1 = group.create()
res2 = group.get()
self.assertEqual(res2.json()["success"], True)
self.assertEqual(res2.json()['group']['name'], group.group_name)
self.assertEqual(res2.json()['group']['description'],
group.description)
self.assertEqual(res2.json()['group']['users'], [user.email])
def test_get_user(self):
group = Group("foo")
res = group.create()
self.assertEqual(True, res.json()['success'])
# Add a user
bob = User(self.email, name="Bob", groups=["foo"])
r = bob.create()
j = r.json()
self.assertEqual(True, r.json()['success'])
# Make sure the user stored in the db is correct
r = User(self.email).get()
j = r.json()
self.assertEqual(True, j['success'])
self.assertEqual(self.email, j['user']['email'])
self.assertEqual("Bob", j['user']['name'])
self.assertEqual(['foo'], j['user']['groups'])
self.assertEqual('user', j['user']['role'])
def _create_plan(self, plan=None):
""" Create a plan in Minion and assign
a site to a group and a user.
Use Plan(self.TEST_PLAN) to test plan only.
"""
_plan = plan or self.TEST_PLAN
self.plan = Plan(_plan)
resp = self.plan.create()
self.user = User(self.email)
self.user.create()
self.site = Site(self.target_url, plans=[self.plan.plan["name"]])
self.site.create()
self.group = Group("testgroup",
sites=[self.site.url],
users=[self.user.email])
self.group.create()
self.plan = Plan(_plan)
return resp
def test_delete_user_also_removes_group_membership(self):
# Create a user and add it to a group
bob = User(self.email)
res = bob.create()
self.assertEqual(res.json()['success'], True)
group = Group(self.group_name, users=[bob.email])
res2 = group.create()
self.assertEqual(res2.json()['success'], True)
# Make sure the user is in the group
res3 = group.get()
self.assertEqual(res3.json()['group']['users'], [bob.email])
# Delete the user
res4 = bob.delete()
self.assertEqual(res4.json()["success"], True)
# Make sure the user is not in the group anymore
res5 = group.get()
self.assertEqual(res5.json()['group']['users'], [])
def test_send_invite_with_groups_and_sites(self):
sender = User(self.email, name="Bob")
sender.create()
recipient = User(self.random_email(), name="Alice")
recipient.invite()
# create the invitation
invite = Invite(sender.email, recipient.email)
res = invite.create()
invite_id = res.json()['invite']['id']
# create a site in minion
site = Site(self.target_url)
res2 = site.create()
site_id = res2.json()["site"]["id"]
# Uncomment the following checks when #297 is resolved.
# create a group in minion
group = Group(self.group_name,
sites=[site.url],
users=[recipient.email])
res3 = group.create()
# site should exists in group and recipient should also be in the same group
res4 = group.get()
self.assertEqual(res4.json()['group']['users'], [
recipient.email,
])
res5 = site.get(site_id)
self.assertEqual(res5.json()["site"]["groups"], [group.group_name])
# finally, if we query recipient's user object, user should be in
# the group and have access to a site.
res6 = recipient.get()
self.assertEqual(res6.json()["user"]["sites"], [site.url])
self.assertEqual(res6.json()["user"]["groups"], [group.group_name])
def test_get_all_groups(self):
group = Group(self.group_name)
res1 = group.create()
res2 = Groups().get()
self.assertEqual(res2.json()["success"], True)
self.assertEqual(res2.json()['groups'][0], res1.json()['group'])
def test_create_group_with_non_existing_site(self):
group = Group(self.group_name, sites=["https://example1.com"])
res = group.create()
self.assertEqual(res.json()['success'], False)
self.assertEqual(res.json()['reason'],
'site https://example1.com does not exist')
def test_create_group_with_non_existing_user(self):
group = Group(self.group_name, users=["user1", "user2"])
res = group.create()
self.assertEqual(res.json()['success'], False)
self.assertEqual(res.json()['reason'], 'user user1 does not exist')
def test_create_group_without_group_name(self):
group = Group(None)
res = group.create()
self.assertEqual(res.json()['success'], False)
self.assertEqual(res.json()['reason'], 'name-field-is-required')
