def setUp(self):
UserFactory.reset_sequence()
self.group = GroupFactory.create()
self.users = UserFactory.create_batch(4, groups=[self.group])
# Make the first user admin
self.users[0].membership_set.filter(group=self.group).update(is_admin=True)
def test_anonymous_existing_user(self):
"""Tests the workflow when a user is connected to the invite already
but the user accepting it is not logged in"""
user2 = UserFactory.create()
invite = GroupInviteFactory.create(group=self.group, email=user2.email, invitor=self.invitor)
self.assertEqual(invite.user, user2)
response = self.client.get(invite.get_response_url())
invite = GroupInvite.objects.get(id=invite.id) # Refresh
self.assertTemplateUsed(response, 'groups/group_invite_already_has_user.html')
self.assertContains(response, reverse("account_login") + "?next=" + invite.get_response_url())
self.assertFalse(invite.responded)
def test_authenticated_existing_user_mismatch(self):
"""Tests the workflow when the invitation is connected to a user
but another user is authenticated and opens the invitation"""
user2 = UserFactory.create()
invite = GroupInviteFactory.create(group=self.group, email=user2.email, invitor=self.invitor)
self.assertEqual(invite.user, user2)
# Login
self.client.login(email=self.user.email, password='******')
response = self.client.get(invite.get_response_url())
invite = GroupInvite.objects.get(id=invite.id) # Refresh
self.assertTemplateUsed(response, 'groups/group_invite_already_has_user.html')
self.assertContains(response, reverse("account_logout") + "?next=" + reverse("account_login"))
self.assertFalse(invite.responded)
def test_group_permissions(self):
"Tests the group permission system"
groups = GroupFactory.create_batch(4)
user_nogroups = UserFactory.create()
user_wgroups = UserFactory.create(groups=groups)
user_wgroup1 = UserFactory.create(groups=groups[0:1])
user_wgroup2 = UserFactory.create(groups=groups[1:2])
user_wgroup3 = UserFactory.create(groups=groups[2:3])
user_wgroup4 = UserFactory.create(groups=groups[3:4])
post_public = PostFactory.create(author=user_nogroups, public=True, tag_set=[TagFactory.create(name='publictag')])
post_private = PostFactory.create(author=user_wgroups, groups=groups[:2])
post_wgroup1 = PostFactory.create(author=user_wgroup1, groups=groups[0:1], tag_set=[TagFactory.create(name='sometag')])
post_wgroup2 = PostFactory.create(author=user_wgroup2, groups=groups[1:2])
post_wgroup3 = PostFactory.create(author=user_wgroup3, groups=groups[2:3])
post_wgroup4 = PostFactory.create(author=user_wgroup4, groups=groups[3:4])
#Post.objects.my_bookmarks(user)
#Post.objects.my_posts(target, user)
self.assertEqual(Post.objects.tag_search("sometag").count(), 0)
self.assertEqual(Post.objects.tag_search("publictag").count(), 1)
# The posts for user who is not member of any group
qs = Post.objects.top_level(user_nogroups)
self.assertEqual(qs.count(), 1, "User without groups should only be able to see the public posts")
self.assertEqual(qs.get(), post_public)
self.assertEqual(Post.objects.tag_search("sometag", user_nogroups).count(), 0)
# The posts for user who is member of all the groups
self.assertEqual(Post.objects.top_level(user_wgroups).count(), 5)
self.assertEqual(Post.objects.tag_search("sometag", user_wgroups).count(), 1)
# Member of group 1
qs = Post.objects.top_level(user_wgroup1)
self.assertEqual(qs.count(), 2)
self.assertEqual(Post.objects.tag_search("sometag", user_wgroup1).count(), 1)
# Member of group 2
qs = Post.objects.top_level(user_wgroup2)
self.assertEqual(qs.count(), 2)
self.assertEqual(Post.objects.tag_search("sometag", user_wgroup2).count(), 0)
# Member of group 3
qs = Post.objects.top_level(user_wgroup3)
self.assertEqual(qs.count(), 1)
self.assertEqual(Post.objects.tag_search("sometag", user_wgroup3).count(), 0)
# Member of group 4
qs = Post.objects.top_level(user_wgroup4)
self.assertEqual(qs.count(), 1)
self.assertEqual(Post.objects.tag_search("sometag", user_wgroup4).count(), 0)
def test_group_permissions(self):
"Tests the group permission system"
groups = GroupFactory.create_batch(4)
user_nogroups = UserFactory.create()
user_wgroups = UserFactory.create(groups=groups)
user_wgroup1 = UserFactory.create(groups=groups[0:1])
user_wgroup2 = UserFactory.create(groups=groups[1:2])
user_wgroup3 = UserFactory.create(groups=groups[2:3])
user_wgroup4 = UserFactory.create(groups=groups[3:4])
post_public = PostFactory.create(title="public test", author=user_nogroups, public=True)
post_private = PostFactory.create(title="private test", author=user_wgroups, groups=groups[:2])
post_wgroup1 = PostFactory.create(title="group1 test", author=user_wgroup1, groups=groups[0:1])
post_wgroup2 = PostFactory.create(title="group2 test", author=user_wgroup2, groups=groups[1:2])
post_wgroup3 = PostFactory.create(title="group3 test", author=user_wgroup3, groups=groups[2:3])
post_wgroup4 = PostFactory.create(title="group4 test", author=user_wgroup4, groups=groups[3:4])
call_command('update_index')
result = json.loads(self.client.get(reverse('search-title'), {'q': 'test'}).content)
self.assertEqual(len(result['items']), 1)
self.assertEqual(result['items'][0]['id'], post_public.get_absolute_url())
result = self.client.get(reverse('search-page'), {'q': 'test'})
self.assertEqual(len(result.context['results']), 1)
self.client.login(email=user_wgroup3.email, password='******')
result = json.loads(self.client.get(reverse('search-title'), {'q': 'test'}).content)
self.assertEqual(len(result['items']), 2)
ids = [i['id'] for i in result['items']]
self.assertIn(post_public.get_absolute_url(), ids)
self.assertIn(post_wgroup3.get_absolute_url(), ids)
result = self.client.get(reverse('search-page'), {'q': 'test'})
self.assertEqual(len(result.context['results']), 2)
def setUp(self):
self.group = GroupFactory.create()
self.invitor = UserFactory.create(groups=[self.group]);
self.invitor.messages.all().delete()
self.user = UserFactory.create();
def setUp(self):
self.user = UserFactory.create()
self.tags = TagFactory.create_batch(2)
self.post = PostFactory.create(author=self.user, tag_set=self.tags)
self.vote = VoteFactory.create(author=self.user, post=self.post)
def setUp(self):
self.group = GroupFactory.create()
self.invitor = UserFactory.create(groups=[self.group]);
self.user = UserFactory.create();
def setUp(self):
UserFactory.reset_sequence()
self.user = UserFactory.create()
self.groups = GroupFactory.create_batch(3)
