def test_group_approve_join_request_view(self):
url = reverse('group_approve_join_request',
kwargs={'pk': self.group.pk})
# Login required
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
# Group does not exist
self.client.login(username='******', password='******')
response = self.client.get(reverse('group_approve_join_request',
kwargs={'pk': 999}),
follow=True)
self.assertEqual(response.status_code, 404)
# Moderator required
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
self.client.logout()
self.group.moderators.add(self.user1)
# Group must be moderated
self.client.login(username='******', password='******')
self.group.moderated = False
self.group.save()
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
self.group.moderated = True
self.group.save()
# User must be in the join requests list
self.client.login(username='******', password='******')
response = self.client.post(url, {'user': self.user2.pk},
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
follow=True)
self.assertEqual(response.status_code, 403)
self.group.join_requests.add(self.user2)
# Request must be AJAX
response = self.client.post(url, {'user': self.user2.pk}, follow=True)
self.assertEqual(response.status_code, 403)
# Success
ToggleProperty.objects.create_toggleproperty("follow", self.user2,
self.user1)
response = self.client.post(url, {'user': self.user2.pk},
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(self.user2 in self.group.members.all())
self.assertFalse(self.user2 in self.group.join_requests.all())
self.assertTrue(len(get_unseen_notifications(self.user2)) > 0)
self.assertIn("APPROVED",
get_unseen_notifications(self.user2)[0].message)
self.assertTrue(len(get_unseen_notifications(self.user1)) > 0)
self.assertIn("joined the public group",
get_unseen_notifications(self.user1)[0].message)
def test_group_invite_view(self):
url = reverse('group_invite', kwargs = {'pk': self.group.pk})
detail_url = reverse('group_detail', kwargs = {'pk': self.group.pk})
# Login required
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
# Owner required
self.client.login(username = '******', password = '******')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self.client.logout()
self.client.login(username = '******', password = '******')
# GET not allowed
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
# Group does not exist
response = self.client.post(reverse('group_invite', kwargs = {'pk': 999}), follow = True)
self.assertEqual(response.status_code, 404)
# Invited user does not exist
response = self.client.post(url,
{
'users[]': [999],
},
HTTP_X_REQUESTED_WITH = 'XMLHttpRequest',
follow = True)
self.assertEqual(response.status_code, 200)
self.group = Group.objects.get(pk = self.group.pk)
self.assertEqual(self.group.invited_users.count(), 0)
# Invitation successful
response = self.client.post(url, {
'users[]': [self.user2.pk,],
},)
self.assertRedirects(response, detail_url, status_code = 302, target_status_code = 200)
self.group = Group.objects.get(pk = self.group.pk)
self.assertEqual(self.group.invited_users.count(), 1)
self.assertEqual(len(get_unseen_notifications(self.user2)), 1)
self.group.invited_users.clear()
# AJAX invitation successful
response = self.client.post(url, {
'users[]': [self.user2.pk,],
}, HTTP_X_REQUESTED_WITH = 'XMLHttpRequest')
self.group = Group.objects.get(pk = self.group.pk)
self.assertEqual(json.loads(response.content)['invited_users'][0]['id'], self.user2.pk)
self.assertEqual(self.group.invited_users.count(), 1)
self.assertEqual(len(get_unseen_notifications(self.user2)), 2)
self.client.logout()
def test_group_invite_view(self):
url = reverse('group_invite', kwargs = {'pk': self.group.pk})
detail_url = reverse('group_detail', kwargs = {'pk': self.group.pk})
# Login required
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
# Owner required
self.client.login(username = '******', password = '******')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self.client.logout()
self.client.login(username = '******', password = '******')
# GET not allowed
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
# Group does not exist
response = self.client.post(reverse('group_invite', kwargs = {'pk': 999}), follow = True)
self.assertEqual(response.status_code, 404)
# Invited user does not exist
response = self.client.post(url,
{
'users[]': [999],
},
HTTP_X_REQUESTED_WITH = 'XMLHttpRequest',
follow = True)
self.assertEqual(response.status_code, 200)
self.group = Group.objects.get(pk = self.group.pk)
self.assertEqual(self.group.invited_users.count(), 0)
# Invitation successful
response = self.client.post(url, {
'users[]': [self.user2.pk,],
},)
self.assertRedirects(response, detail_url, status_code = 302, target_status_code = 200)
self.group = Group.objects.get(pk = self.group.pk)
self.assertEqual(self.group.invited_users.count(), 1)
self.assertEqual(len(get_unseen_notifications(self.user2)), 1)
self.group.invited_users.clear()
# AJAX invitation successful
response = self.client.post(url, {
'users[]': [self.user2.pk,],
}, HTTP_X_REQUESTED_WITH = 'XMLHttpRequest')
self.group = Group.objects.get(pk = self.group.pk)
self.assertEqual(json.loads(response.content)['invited_users'][0]['id'], self.user2.pk)
self.assertEqual(self.group.invited_users.count(), 1)
self.assertEqual(len(get_unseen_notifications(self.user2)), 2)
self.client.logout()
def notices_count(request):
response = {}
if request.user.is_authenticated():
count = get_unseen_notifications(request.user, -1).count()
response['notifications_count'] = count
return response
def notices_count(request):
response = {}
if request.user.is_authenticated():
count = get_unseen_notifications(request.user, -1).count()
response['notifications_count'] = count
return response
def test_group_approve_join_request_view(self):
url = reverse('group_approve_join_request', kwargs = {'pk': self.group.pk})
# Login required
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
# Group does not exist
self.client.login(username = '******', password = '******')
response = self.client.get(reverse('group_approve_join_request', kwargs = {'pk': 999}), follow = True)
self.assertEqual(response.status_code, 404)
# Moderator required
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 403)
self.client.logout()
self.group.moderators.add(self.user1)
# Group must be moderated
self.client.login(username = '******', password = '******')
self.group.moderated = False; self.group.save()
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 403)
self.group.moderated = True; self.group.save()
# User must be in the join requests list
self.client.login(username = '******', password = '******')
response = self.client.post(url, {'user': self.user2.pk}, HTTP_X_REQUESTED_WITH = 'XMLHttpRequest', follow = True)
self.assertEqual(response.status_code, 403)
self.group.join_requests.add(self.user2)
# Request must be AJAX
response = self.client.post(url, {'user': self.user2.pk}, follow = True)
self.assertEqual(response.status_code, 403)
# Success
ToggleProperty.objects.create_toggleproperty("follow", self.user2, self.user1)
response = self.client.post(url, {'user': self.user2.pk}, HTTP_X_REQUESTED_WITH = 'XMLHttpRequest', follow = True)
self.assertEqual(response.status_code, 200)
self.assertTrue(self.user2 in self.group.members.all())
self.assertFalse(self.user2 in self.group.join_requests.all())
self.assertTrue(len(get_unseen_notifications(self.user2)) > 0)
self.assertIn("APPROVED", get_unseen_notifications(self.user2)[0].message)
self.assertTrue(len(get_unseen_notifications(self.user1)) > 0)
self.assertIn("joined the public group", get_unseen_notifications(self.user1)[0].message)
def notifications_table(user, unseen_count, seen_count):
unseen = get_unseen_notifications(user, unseen_count)
seen = get_seen_notifications(user, seen_count)
return {
'unseen': unseen,
'seen': seen,
}
def notifications_table(user, unseen_count, seen_count):
unseen = get_unseen_notifications(user, unseen_count)
seen = get_seen_notifications(user, seen_count)
return {
'unseen': unseen,
'seen': seen,
'username': user.username
}
def has_unseen_notifications(user):
if not user.is_authenticated():
return False
return get_unseen_notifications(user, -1).count() > 0
def test_group_join_view(self):
url = reverse('group_join', kwargs = {'pk': self.group.pk})
# Login required
response = self.client.post(url)
self.assertEqual(response.status_code, 302)
self.client.login(username = '******', password = '******')
# GET not allowed
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
# Group does not exist
response = self.client.post(reverse('group_join', kwargs = {'pk': 999}), follow = True)
self.assertEqual(response.status_code, 404)
self.client.logout()
self.client.login(username = '******', password = '******')
# Private group, uninvited user
self.group.public = False; self.group.save()
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 403)
self.group.public = True; self.group.save()
# Public group, but moderated
self.group.moderated = True; self.group.save()
self.group.moderators.add(self.group.owner);
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "warning unread", "This is a moderated group, and your join request will be reviewed by a moderator")
self.assertTrue(len(get_unseen_notifications(self.user1)) > 0)
self.assertIn("requested to join the group", get_unseen_notifications(self.user1)[0].message)
self.assertTrue(self.user2 in self.group.join_requests.all())
self.group.moderated = False; self.group.save()
self.group.moderators.clear()
# Join successful
ToggleProperty.objects.create_toggleproperty("follow", self.user2, self.user1)
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread", "You have joined the group")
self.assertTrue(self.user2 in self.group.members.all())
self.assertTrue(len(get_unseen_notifications(self.user1)) > 0)
self.assertIn("joined the public group", get_unseen_notifications(self.user1)[0].message)
# Second attempt results in error "already joined"
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "error unread", "You already were a member of this group")
self.group.members.remove(self.user2)
# If the group is not public, only invited members can join
self.group.public = False; self.group.save()
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 403)
self.group.invited_users.add(self.user2)
response = self.client.post(url, follow = True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread", "You have joined the group")
self.assertTrue(self.user2 in self.group.members.all())
self.assertFalse(self.user2 in self.group.invited_users.all())
# Restore group state
self.group.invited_users.clear()
self.group.members.clear()
self.group.join_requests.clear()
self.group.public = True
self.group.save()
self.client.logout()
def test_group_create_view(self):
url = reverse('group_create')
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
# Add user2 to user1's followers to check notification
ToggleProperty.objects.create_toggleproperty("follow", self.user1, self.user2)
self.client.login(username = '******', password = '******')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
response = self.client.post(url, {
'name': 'Test create group',
'description': 'Description',
'category': 101,
'public': True,
'moderated': True,
}, follow = True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread", "Your new group was created successfully")
group = Group.objects.all().order_by('-pk')[0]
self.assertEqual(group.creator, self.user1)
self.assertEqual(group.owner, self.user1)
self.assertEqual(group.name, 'Test create group')
self.assertEqual(group.description, 'Description')
self.assertEqual(group.category, 101)
self.assertEqual(group.public, True)
self.assertEqual(group.moderated, True)
self.assertTrue(group.owner in group.members.all())
self.assertTrue(group.owner in group.moderators.all())
self.assertTrue(group.forum != None)
self.assertTrue(len(get_unseen_notifications(self.user2)) > 0)
self.assertIn("created a new public group", get_unseen_notifications(self.user2)[0].message)
group.delete()
# Creating a private group does not trigger notifications
response = self.client.post(url, {
'name': 'Test create group',
'description': 'Description',
'category': 101,
'public': False,
}, follow = True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread", "Your new group was created successfully")
group = Group.objects.all().order_by('-pk')[0]
self.assertEqual(group.public, False)
self.assertEqual(len(get_unseen_notifications(self.user2)), 1) # Notitication from before
group.delete()
# Test the autosubmission/category combo
response = self.client.post(url, {
'name': 'Test create group',
'description': 'Description',
'category': 101,
'autosubmission': True,
}, follow = True)
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', 'category',
"Only the following category support autosubmission: " \
"Professional network, Club or association, " \
"Internet commmunity, Friends or partners, Geographical area"
)
self.client.logout()
def test_group_join_view(self):
url = reverse('group_join', kwargs={'pk': self.group.pk})
# Login required
response = self.client.post(url)
self.assertEqual(response.status_code, 302)
self.client.login(username='******', password='******')
# Free users can't access.
self.client.login(username='******', password='******')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
us1 = Generators.premium_subscription(self.user1,
"AstroBin Ultimate 2020+")
# GET not allowed
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
# Group does not exist
response = self.client.post(reverse('group_join', kwargs={'pk': 999}),
follow=True)
self.assertEqual(response.status_code, 404)
self.client.logout()
self.client.login(username='******', password='******')
us2 = Generators.premium_subscription(self.user2,
"AstroBin Ultimate 2020+")
# Private group, uninvited user
self.group.public = False
self.group.save()
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
self.group.public = True
self.group.save()
# Public group, but moderated
self.group.moderated = True
self.group.save()
self.group.moderators.add(self.group.owner)
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self._assertMessage(
response, "warning unread",
"This is a moderated group, and your join request will be reviewed by a moderator"
)
self.assertTrue(len(get_unseen_notifications(self.user1)) > 0)
self.assertIn("requested to join the group",
get_unseen_notifications(self.user1)[0].message)
self.assertTrue(self.user2 in self.group.join_requests.all())
self.group.moderated = False
self.group.save()
self.group.moderators.clear()
# Join successful
ToggleProperty.objects.create_toggleproperty("follow", self.user2,
self.user1)
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread",
"You have joined the group")
self.assertTrue(self.user2 in self.group.members.all())
self.assertTrue(len(get_unseen_notifications(self.user1)) > 0)
self.assertIn("joined the public group",
get_unseen_notifications(self.user1)[0].message)
# Second attempt results in error "already joined"
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "error unread",
"You already were a member of this group")
self.group.members.remove(self.user2)
# If the group is not public, only invited members can join
self.group.public = False
self.group.save()
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
self.group.invited_users.add(self.user2)
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread",
"You have joined the group")
self.assertTrue(self.user2 in self.group.members.all())
self.assertFalse(self.user2 in self.group.invited_users.all())
# Restore group state
self.group.invited_users.clear()
self.group.members.clear()
self.group.join_requests.clear()
self.group.public = True
self.group.save()
self.client.logout()
us1.delete()
us2.delete()
def test_group_create_view(self):
url = reverse('group_create')
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
# Add user2 to user1's followers to check notification
ToggleProperty.objects.create_toggleproperty("follow", self.user1,
self.user2)
# Free users can't access.
self.client.login(username='******', password='******')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
us = Generators.premium_subscription(self.user1,
"AstroBin Ultimate 2020+")
self.client.login(username='******', password='******')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
response = self.client.post(url, {
'name': 'Test create group',
'description': 'Description',
'category': 101,
'public': True,
'moderated': True,
},
follow=True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread",
"Your new group was created successfully")
group = Group.objects.all().order_by('-pk')[0]
self.assertEqual(group.creator, self.user1)
self.assertEqual(group.owner, self.user1)
self.assertEqual(group.name, 'Test create group')
self.assertEqual(group.description, 'Description')
self.assertEqual(group.category, 101)
self.assertEqual(group.public, True)
self.assertEqual(group.moderated, True)
self.assertTrue(group.owner in group.members.all())
self.assertTrue(group.owner in group.moderators.all())
self.assertTrue(group.forum != None)
self.assertTrue(len(get_unseen_notifications(self.user2)) > 0)
self.assertIn("created a new public group",
get_unseen_notifications(self.user2)[0].message)
group.delete()
# Creating a private group does not trigger notifications
response = self.client.post(url, {
'name': 'Test create group',
'description': 'Description',
'category': 101,
'public': False,
},
follow=True)
self.assertEqual(response.status_code, 200)
self._assertMessage(response, "success unread",
"Your new group was created successfully")
group = Group.objects.all().order_by('-pk')[0]
self.assertEqual(group.public, False)
self.assertEqual(len(get_unseen_notifications(self.user2)),
1) # Notitication from before
group.delete()
# Test the autosubmission/category combo
response = self.client.post(url, {
'name': 'Test create group',
'description': 'Description',
'category': 101,
'autosubmission': True,
},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', 'category',
"Only the following category support autosubmission: " \
"Professional network, Club or association, " \
"Internet commmunity, Friends or partners, Geographical area"
)
self.client.logout()
us.delete()
def has_unseen_notifications(user):
if not user.is_authenticated():
return False
return get_unseen_notifications(user, -1).count() > 0
