def test_join_open_group(self):
# Joining a map group if you are already a member returns your
# membership card.
result = join_map_group(self.users['usr1'], self.open_group)
self.assertIsInstance(result, MapGroupMember)
# Make sure the user gets added to the permission group
pgroup_name = self.open_group.permission_group.name
user_pgroup = self.users['usr1'].groups.filter(name=pgroup_name)
self.assertTrue(user_pgroup.exists())
# If it's an open group, then joining will succeed
result = join_map_group(self.users['usr2'], self.open_group)
self.assertIsInstance(result, MapGroupMember)
self.assertEqual(result.user, self.users['usr2'])
# Make sure the user gets added to the permission group
pgroup_name = self.open_group.permission_group.name
user_pgroup = self.users['usr2'].groups.filter(name=pgroup_name)
self.assertTrue(user_pgroup.exists())
log = ActivityLog.objects.filter(group=self.open_group, admin=True,
associated_user=self.users['usr2'])
self.assertTrue(log.exists())
def test_join_closed_group(self):
# Verify that we can't join a closed group
result = join_map_group(self.users['usr1'], self.closed_group)
self.assertIsNone(result)
invite, new = request_map_group_invitation(self.users['usr1'],
self.closed_group)
self.assertIsInstance(invite, Invitation)
self.assertTrue(new)
log = ActivityLog.objects.filter(group=self.closed_group, admin=True,
associated_user=self.users['usr1'])
self.assertTrue(log.exists())
# request the invitation again
invite2, new = request_map_group_invitation(self.users['usr1'],
self.closed_group)
self.assertEqual(invite2, invite)
self.assertFalse(new)
# try to request an invite for an existing member
invite, new = request_map_group_invitation(self.users['usr2'],
self.closed_group)
self.assertIsNone(invite)
self.assertFalse(new)
def form_valid(self, form):
member = join_map_group(self.request.user, self.mapgroup)
if not member:
# then it's a closed group and we need an invite
pass
return super(RequestJoinMapGroupActionView, self).form_valid(form)
def handle(self, request, *args, **kwargs):
self.mapgroup = MapGroup.objects.get(pk=kwargs['pk'])
self.success_url = reverse('mapgroups:detail', kwargs=kwargs)
member = join_map_group(self.request.user, self.mapgroup)
if not member:
# then it's a closed group and we need an invite
pass
return HttpResponseRedirect(self.success_url)
def test_edit(self):
c = Client()
self.assertTrue(c.login(username=self.users['usr1'].username,
password='******'))
# add some members to test renaming
join_map_group(self.users['usr2'], self.mg)
join_map_group(self.users['usr3'], self.mg)
# TODO: test group membership the right way
self.assertTrue(self.users['usr2'].groups.filter(name=self.mg.permission_group.name).exists())
self.assertTrue(self.users['usr3'].groups.filter(name=self.mg.permission_group.name).exists())
data = {
'name': 'Tarantula Tuesdays',
'blurb': "It's totally not creepy",
'is_open': False, # you must be *invited* to tarantula tuesdays
}
url = reverse('mapgroups:edit', kwargs={'pk': self.mg.pk,
'slug': self.mg.slug})
resp = c.post(url, data)
self.assertEqual(resp.status_code, 302)
self.assertEqual(resp.status_code, 302)
mg = MapGroup.objects.get(pk=self.mg.pk)
self.assertEqual(mg.name, data['name'])
self.assertEqual(mg.blurb, data['blurb'])
self.assertEqual(mg.is_open, data['is_open'])
self.assertEqual(mg.owner, self.users['usr1'])
old_pg = Group.objects.filter(name=self.mg.permission_group.name)
self.assertFalse(old_pg.exists(), "Old permission group wasn't deleted")
pg = Group.objects.filter(name=mg.permission_group.name)
self.assertTrue(pg.exists(), "New permission group doesn't exist")
self.assertTrue(mg.owner.groups.filter(name=mg.permission_group.name).exists())
self.assertTrue(self.users['usr2'].groups.filter(name=mg.permission_group.name).exists())
self.assertTrue(self.users['usr3'].groups.filter(name=mg.permission_group.name).exists())
def test_leave_group(self):
user = self.users['usr2']
group = self.group
result = join_map_group(user, group)
self.assertIsInstance(result, MapGroupMember)
self.assertTrue(group.has_member(user))
self.assertTrue(group.permission_group.user_set.filter(pk=user.pk).exists())
result = leave_non_owned_map_group(user, group)
self.assertTrue(result)
self.assertFalse(group.has_member(user))
self.assertFalse(group.permission_group.user_set.filter(pk=user.pk).exists())
