def setup(self):
self.loadstatement = '{% load forum_permission_tags %}'
self.request_factory = RequestFactory()
self.g1 = GroupFactory.create()
self.u1 = UserFactory.create()
self.u2 = UserFactory.create()
self.u1.groups.add(self.g1)
self.u2.groups.add(self.g1)
self.moderators = GroupFactory.create()
self.moderator = UserFactory.create()
self.moderator.groups.add(self.moderators)
self.superuser = UserFactory.create(is_superuser=True)
# Permission handler
self.perm_handler = PermissionHandler()
# Set up a top-level category
self.top_level_cat = create_category_forum()
# Set up some forums
self.forum_1 = create_forum(parent=self.top_level_cat)
self.forum_2 = create_forum(parent=self.top_level_cat)
# Set up some topics and posts
self.forum_1_topic = create_topic(forum=self.forum_1, poster=self.u1)
self.forum_2_topic = create_topic(forum=self.forum_2, poster=self.u2)
self.post_1 = PostFactory.create(topic=self.forum_1_topic, poster=self.u1)
self.post_2 = PostFactory.create(topic=self.forum_2_topic, poster=self.u2)
def setup(self):
self.u1 = UserFactory.create()
self.g1 = GroupFactory.create()
self.u1.groups.add(self.g1)
# Permission handler
self.perm_handler = PermissionHandler()
# Set up a top-level category
self.top_level_cat = create_category_forum()
# Set up some forums
self.forum_1 = create_forum(parent=self.top_level_cat)
self.forum_2 = create_forum(parent=self.top_level_cat)
self.forum_3 = create_link_forum(parent=self.top_level_cat)
# Set up a top-level forum link
self.top_level_link = create_link_forum()
# Set up some topics
self.forum_1_topic = create_topic(forum=self.forum_1, poster=self.u1)
self.forum_3_topic = create_topic(forum=self.forum_3, poster=self.u1)
self.forum_3_topic_2 = create_topic(
forum=self.forum_3, poster=self.u1, status=Topic.TOPIC_LOCKED)
# Set up some posts
self.post_1 = PostFactory.create(topic=self.forum_1_topic, poster=self.u1)
self.post_2 = PostFactory.create(topic=self.forum_3_topic, poster=self.u1)
# Assign some permissions
assign_perm('can_see_forum', self.u1, self.top_level_cat)
assign_perm('can_see_forum', self.u1, self.forum_1)
assign_perm('can_read_forum', self.g1, self.forum_3)
def test_says_that_a_topic_with_a_last_post_date_greater_than_the_forum_mark_time_is_unread(self): # noqa
# Setup
PostFactory.create(topic=self.topic, poster=self.u1)
# Run
unread_topics = self.tracks_handler.get_unread_topics(self.forum_2.topics.all(), self.u2)
# Check
assert unread_topics == [self.topic, ]
def test_can_determine_unread_forums(self):
# Setup
def get_rendered(topics, user):
request = self.get_request()
request.user = user
ForumPermissionMiddleware().process_request(request)
t = Template(self.loadstatement + '{% get_unread_topics topics request.user as unread_topics %}')
c = Context({'topics': topics, 'request': request})
rendered = t.render(c)
return c, rendered
# Run & check
context, rendered = get_rendered(self.forum_2.topics.all(), self.u2)
assert rendered == ''
assert set(context['unread_topics']) == set(self.forum_2.topics.all())
# forum_2 topics are now read
TopicReadTrackFactory.create(topic=self.forum_2_topic, user=self.u2)
context, rendered = get_rendered(self.forum_2.topics.all(), self.u2)
assert rendered == ''
assert not len(context['unread_topics'])
# A new post is created with a pre-existing topic track
PostFactory.create(topic=self.forum_2_topic, poster=self.u1)
context, rendered = get_rendered(self.forum_2.topics.all(), self.u2)
assert rendered == ''
assert set(context['unread_topics']) == set(self.forum_2.topics.all())
# A new post is created with a pre-existing forum track
ForumReadTrackFactory.create(forum=self.forum_1, user=self.u2)
PostFactory.create(topic=self.forum_1_topic, poster=self.u1)
context, rendered = get_rendered(self.forum_1.topics.all(), self.u2)
assert rendered == ''
assert set(context['unread_topics']) == set(self.forum_1.topics.all())
def test_can_determine_unread_forums(self):
# Setup
def get_rendered(forums, user):
request = self.get_request()
request.user = user
ForumPermissionMiddleware().process_request(request)
t = Template(self.loadstatement + '{% get_unread_forums forums request.user as unread_forums %}')
c = Context({'forums': forums, 'request': request})
rendered = t.render(c)
return c, rendered
# Run & check
context, rendered = get_rendered(Forum.objects.all(), self.u2)
assert rendered == ''
assert set(context['unread_forums']) == set([self.top_level_cat, self.forum_1, self.forum_2, ])
# forum_1 and forum_2 are now read
ForumReadTrackFactory.create(forum=self.forum_1, user=self.u2)
ForumReadTrackFactory.create(forum=self.forum_2, user=self.u2)
context, rendered = get_rendered(Forum.objects.all(), self.u2)
assert rendered == ''
assert not len(context['unread_forums'])
# A new post is created
PostFactory.create(topic=self.forum_2_topic, poster=self.u1)
context, rendered = get_rendered(Forum.objects.all(), self.u2)
assert rendered == ''
assert set(context['unread_forums']) == set([self.forum_2, self.top_level_cat])
def setUp(self):
self.loadstatement = '{% load forum_tracking_tags %}'
self.request_factory = RequestFactory()
# Tracking handler
self.tracks_handler = TrackingHandler()
self.g1 = GroupFactory.create()
self.u1 = UserFactory.create()
self.u2 = UserFactory.create()
self.u1.groups.add(self.g1)
self.u2.groups.add(self.g1)
# Set up a top-level category
self.top_level_cat = create_category_forum()
# Set up some forums
self.forum_1 = create_forum(parent=self.top_level_cat)
self.forum_2 = create_forum(parent=self.top_level_cat)
# Set up some topics and posts
self.forum_1_topic = create_topic(forum=self.forum_1, poster=self.u1)
self.forum_2_topic = create_topic(forum=self.forum_2, poster=self.u1)
self.post_1 = PostFactory.create(topic=self.forum_1_topic, poster=self.u1)
self.post_2 = PostFactory.create(topic=self.forum_2_topic, poster=self.u1)
# Assign some permissions
assign_perm('can_see_forum', self.g1, self.top_level_cat)
assign_perm('can_read_forum', self.g1, self.top_level_cat)
assign_perm('can_see_forum', self.g1, self.forum_1)
assign_perm('can_read_forum', self.g1, self.forum_1)
assign_perm('can_see_forum', self.g1, self.forum_2)
assign_perm('can_read_forum', self.g1, self.forum_2)
def setup(self):
# Create a basic user
self.user = UserFactory.create()
# Permission handler
self.perm_handler = PermissionHandler()
# Set up a top-level forum
self.cat = create_category_forum()
self.top_level_forum = create_forum()
self.other_forum = create_forum()
# Set up a topic and some posts
self.topic = create_topic(forum=self.top_level_forum, poster=self.user)
self.first_post = PostFactory.create(topic=self.topic, poster=self.user)
self.post = PostFactory.create(topic=self.topic, poster=self.user)
# Mark the forum as read
ForumReadTrackFactory.create(forum=self.top_level_forum, user=self.user)
# Assign some permissions
assign_perm('can_read_forum', self.user, self.top_level_forum)
assign_perm('can_reply_to_topics', self.user, self.top_level_forum)
assign_perm('can_edit_own_posts', self.user, self.top_level_forum)
assign_perm('can_delete_own_posts', self.user, self.top_level_forum)
assign_perm('can_lock_topics', self.user, self.top_level_forum)
def test_can_mark_topics_read(self):
# Setup
new_topic = create_topic(forum=self.forum_2, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
# Run
self.tracks_handler.mark_topic_read(new_topic, self.u2)
# Check
assert list(self.tracks_handler.get_unread_forums(self.u2)) == []
def test_cannot_tell_that_a_non_approved_post_is_the_last_post(self):
# Setup
create_topic(forum=self.top_level_forum, poster=self.u1)
# Run & check
middle_post = PostFactory.create(topic=self.topic, poster=self.u1)
PostFactory.create(topic=self.topic, poster=self.u1, approved=False)
self.topic.refresh_from_db()
assert self.topic.last_post == middle_post
def test_cannot_update_its_last_post_date_with_the_creation_date_of_a_non_approved_post(self):
# Setup
create_topic(forum=self.top_level_forum, poster=self.u1)
# Run & check
middle_post = PostFactory.create(topic=self.topic, poster=self.u1)
PostFactory.create(topic=self.topic, poster=self.u1, approved=False)
self.topic.refresh_from_db()
assert self.topic.last_post_on == middle_post.created
def test_do_nothing_if_the_poster_is_anonymous(self):
# Setup
top_level_forum = create_forum()
topic = create_topic(forum=top_level_forum, poster=None)
# Run
PostFactory.create(topic=topic, poster=None, username='******')
# Check
assert ForumProfile.objects.exists() is False
def test_cannot_say_that_a_forum_is_unread_if_it_is_not_visible_by_the_user(self):
# Setup
new_topic = create_topic(forum=self.forum_3, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
# Run
unread_forums = self.tracks_handler.get_unread_forums(self.u2)
# Check
assert self.forum_3 not in unread_forums
def test_says_that_a_topic_is_unread_if_the_related_forum_is_not_marked(self):
# Setup
new_topic = create_topic(forum=self.forum_3, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
# Run
unread_topics = self.tracks_handler.get_unread_topics(self.forum_3.topics.all(), self.u2)
# Check
assert unread_topics == [new_topic, ]
def test_cannot_say_that_post_is_the_last_post_if_it_is_not_approved(self):
# Setup
PostFactory.create(topic=self.forum_1_topic, poster=self.u1, approved=False)
remove_perm('can_read_forum', self.g1, self.forum_3)
# Run
last_post = self.perm_handler.get_forum_last_post(self.top_level_cat, self.u1)
# Check
assert last_post == self.post_1
def test_knows_its_position_inside_the_topic(self):
# Setup
post_2 = PostFactory.create(topic=self.topic, poster=self.u1)
post_3 = PostFactory.create(topic=self.topic, poster=self.u1)
# Run & check
assert self.post.position == 1
assert post_2.position == 2
assert post_3.position == 3
def test_says_that_a_topic_with_a_creation_date_greater_than_the_forum_mark_time_is_unread(self):
# Setup
new_topic = create_topic(forum=self.forum_2, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
# Run
unread_topics = self.tracks_handler.get_unread_topics(self.forum_2.topics.all(), self.u2)
# Check
assert unread_topics == [new_topic]
def test_can_tell_if_a_forum_is_unread(self):
# Setup
PostFactory.create(topic=self.topic, poster=self.u1)
# Run
unread_forums = ForumReadTrack.objects.get_unread_forums_from_list(
self.top_level_cat_1.get_descendants(include_self=True),
self.u2)
# Check
assert self.forum_2 in unread_forums
def test_cannot_tell_that_the_descendant_of_an_unread_forum_are_also_unread(self):
# Setup
PostFactory.create(topic=self.topic, poster=self.u1)
# Run
unread_forums = ForumReadTrack.objects.get_unread_forums_from_list(
self.top_level_cat_1.get_descendants(include_self=True),
self.u2)
# Check
assert self.forum_2_child_2 not in unread_forums
def test_cannot_say_that_a_topic_is_unread_if_it_has_been_marked(self):
# Setup
PostFactory.create(topic=self.topic, poster=self.u1)
new_topic = create_topic(forum=self.forum_2, poster=self.u1)
TopicReadTrackFactory.create(topic=self.topic, user=self.u2)
# Run
unread_topics = self.tracks_handler.get_unread_topics(self.forum_2.topics.all(), self.u2)
# Check
assert unread_topics == [new_topic, ]
def test_marks_parent_forums_as_read_when_marking_a_list_of_forums_as_read(self):
# Setup
new_topic = create_topic(forum=self.forum_2_child_2, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
# Run
self.tracks_handler.mark_forums_read([self.forum_2_child_2, ], self.u2)
# Check
assert list(self.tracks_handler.get_unread_forums(self.u2)) == []
assert ForumReadTrack.objects.filter(user=self.u2).count() == 3
def test_cannot_mark_forums_read_for_anonymous_users(self):
# Setup
new_topic = create_topic(forum=self.forum_2, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
initial_read_tracks_count = ForumReadTrack.objects.count()
# Run
self.tracks_handler.mark_forums_read(Forum.objects.all(), AnonymousUser())
# Check
assert ForumReadTrack.objects.count() == initial_read_tracks_count
def test_can_mark_all_readable_forums_read(self):
# Setup
new_topic = create_topic(forum=self.forum_2, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
correct_url = reverse('forum_tracking:mark_all_forums_read')
# Run
response = self.client.get(correct_url, follow=True)
# Check
assert response.status_code == 200
assert list(self.tracks_handler.get_unread_forums(self.user)) == []
def test_does_not_consider_non_approved_posts(self):
# Setup
topic_5 = create_topic(forum=self.forum_2, poster=self.user)
PostFactory.create(topic=topic_5, poster=self.user, approved=False)
correct_url = reverse('forum_member:user_topics')
# Run
response = self.client.get(correct_url, follow=True)
# Check
assert response.status_code == 200
assert list(response.context_data['topics']) == [self.topic_4, self.topic_2, self.topic_1, ]
def test_can_send_a_specific_signal_when_a_forum_is_moved(self):
# Setup
topic = create_topic(forum=self.top_level_forum, poster=self.u1)
PostFactory.create(topic=topic, poster=self.u1)
PostFactory.create(topic=topic, poster=self.u1)
# Run & check
with mock_signal_receiver(forum_moved) as receiver:
self.top_level_forum.parent = self.top_level_cat
self.top_level_forum.save()
assert receiver.call_count == 1
def test_cannot_insert_unapproved_topics_into_the_context(self):
# Setup
new_topic = create_topic(forum=self.forum_4, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1, approved=False)
correct_url = reverse('forum_tracking:unread_topics')
# Run
response = self.client.get(correct_url, follow=True)
# Check
assert response.status_code == 200
assert not response.context_data['topics']
def test_cannot_consider_a_forum_without_tracks_as_unread_if_it_has_only_unapproved_topics(self):
# Setup
new_topic = create_topic(forum=self.forum_2_child_2, poster=self.u2)
PostFactory.create(topic=new_topic, poster=self.u2, approved=False)
# Run
unread_forums = ForumReadTrack.objects.get_unread_forums_from_list(
self.top_level_cat_1.get_descendants(include_self=True),
self.u1)
# Check
assert self.forum_2_child_2 not in unread_forums
def test_can_mark_forum_topics_read(self):
# Setup
new_topic = create_topic(forum=self.forum_4, poster=self.u1)
PostFactory.create(topic=new_topic, poster=self.u1)
correct_url = reverse('forum_tracking:mark_topics_read', kwargs={'pk': self.forum_4.pk})
# Run
response = self.client.get(correct_url, follow=True)
# Check
assert response.status_code == 200
assert list(self.tracks_handler.get_unread_topics(self.forum_4.topics.all(), self.user)) == []
def test_can_reset_last_post_datetime_if_all_topics_have_been_deleted(self):
# Setup
sub_level_forum = create_forum(parent=self.top_level_forum)
topic = create_topic(forum=sub_level_forum, poster=self.u1)
PostFactory.create(topic=topic, poster=self.u1)
# Run
topic.delete()
# Check
sub_level_forum.refresh_from_db()
assert sub_level_forum.last_post_on is None
def test_stores_its_last_post_datetime(self):
# Setup
sub_level_forum = create_forum(parent=self.top_level_forum)
topic = create_topic(forum=sub_level_forum, poster=self.u1)
PostFactory.create(topic=topic, poster=self.u1)
# Run
p2 = PostFactory.create(topic=topic, poster=self.u1)
# Check
sub_level_forum.refresh_from_db()
assert sub_level_forum.last_post_on == p2.created
def setup(self):
self.factory = RequestFactory()
self.user = UserFactory.create()
# Set up the following forum tree:
#
# top_level_cat
# forum_1
# forum_2
# forum_2_child_1
# top_level_forum_1
# top_level_forum_2
# sub_cat
# sub_sub_forum
# top_level_forum_3
# forum_3
# forum_3_child_1
# forum_3_child_1_1
# deep_forum
# last_forum
#
self.top_level_cat = create_category_forum()
self.forum_1 = create_forum(parent=self.top_level_cat)
self.forum_2 = create_forum(parent=self.top_level_cat)
self.forum_2_child_1 = create_forum(parent=self.forum_2)
self.top_level_forum_1 = create_forum()
self.top_level_forum_2 = create_forum()
self.sub_cat = create_category_forum(parent=self.top_level_forum_2)
self.sub_sub_forum = create_forum(parent=self.sub_cat)
self.top_level_forum_3 = create_forum()
self.forum_3 = create_forum(parent=self.top_level_forum_3)
self.forum_3_child_1 = create_forum(parent=self.forum_3)
self.forum_3_child_1_1 = create_forum(parent=self.forum_3_child_1)
self.deep_forum = create_forum(parent=self.forum_3_child_1_1)
self.last_forum = create_forum()
# Set up a topic and some posts
self.topic_1 = create_topic(forum=self.forum_1, poster=self.user)
self.post_1 = PostFactory.create(topic=self.topic_1, poster=self.user)
self.topic_2 = create_topic(forum=self.forum_2, poster=self.user)
self.post_2 = PostFactory.create(topic=self.topic_2, poster=self.user)
self.topic_3 = create_topic(forum=self.forum_2_child_1, poster=self.user)
self.post_3 = PostFactory.create(topic=self.topic_3, poster=self.user)
# Assign some permissions
assign_perm('can_read_forum', self.user, self.top_level_cat)
assign_perm('can_read_forum', self.user, self.forum_1)
assign_perm('can_read_forum', self.user, self.forum_2)
assign_perm('can_read_forum', self.user, self.forum_2_child_1)
assign_perm('can_read_forum', self.user, self.top_level_forum_1)
def setup(self):
# Permission handler
self.perm_handler = PermissionHandler()
# Create a basic user
self.user = UserFactory.create(username='******')
# Set up the following forum tree:
#
# top_level_cat
# forum_1
# forum_2
# forum_2_child_1
# top_level_forum_1
# top_level_forum_2
# sub_cat
# sub_sub_forum
# top_level_forum_3
# forum_3
# forum_3_child_1
# forum_3_child_1_1
# deep_forum
# last_forum
#
self.top_level_cat = create_category_forum()
self.forum_1 = create_forum(parent=self.top_level_cat)
self.forum_2 = create_forum(parent=self.top_level_cat)
self.forum_2_child_1 = create_forum(parent=self.forum_2)
self.top_level_forum_1 = create_forum()
self.top_level_forum_2 = create_forum()
self.sub_cat = create_category_forum(parent=self.top_level_forum_2)
self.sub_sub_forum = create_forum(parent=self.sub_cat)
self.top_level_forum_3 = create_forum()
self.forum_3 = create_forum(parent=self.top_level_forum_3)
self.forum_3_child_1 = create_forum(parent=self.forum_3)
self.forum_3_child_1_1 = create_forum(parent=self.forum_3_child_1)
self.deep_forum = create_forum(parent=self.forum_3_child_1_1)
self.last_forum = create_forum()
# Set up a topic and some posts
self.topic_1 = create_topic(forum=self.forum_1, poster=self.user)
self.post_1 = PostFactory.create(topic=self.topic_1, poster=self.user)
self.topic_2 = create_topic(forum=self.forum_2, poster=self.user)
self.post_2 = PostFactory.create(topic=self.topic_2, poster=self.user)
self.topic_3 = create_topic(forum=self.forum_2_child_1,
poster=self.user)
self.post_3 = PostFactory.create(topic=self.topic_3, poster=self.user)
# Assign some permissions
assign_perm('can_read_forum', self.user, self.top_level_cat)
assign_perm('can_read_forum', self.user, self.forum_1)
assign_perm('can_read_forum', self.user, self.forum_2)
assign_perm('can_read_forum', self.user, self.forum_2_child_1)
assign_perm('can_read_forum', self.user, self.top_level_forum_1)
self.sqs = SearchQuerySet()
management.call_command('clear_index', verbosity=0, interactive=False)
management.call_command('update_index', verbosity=0)
yield
# teardown
# --
management.call_command('clear_index', verbosity=0, interactive=False)
def setup(self):
# Add some users
self.u1 = UserFactory.create()
self.g1 = GroupFactory.create()
self.u1.groups.add(self.g1)
self.user.groups.add(self.g1)
# Permission handler
self.perm_handler = PermissionHandler()
self.top_level_cat_1 = create_category_forum()
self.forum_1 = create_forum(parent=self.top_level_cat_1)
self.forum_2 = create_forum(parent=self.top_level_cat_1)
self.forum_3 = create_forum(parent=self.top_level_cat_1)
self.topic_1 = create_topic(forum=self.forum_2, poster=self.u1)
PostFactory.create(topic=self.topic_1, poster=self.u1)
PostFactory.create(topic=self.topic_1, poster=self.user)
self.topic_2 = create_topic(forum=self.forum_1, poster=self.user)
PostFactory.create(topic=self.topic_2, poster=self.user)
PostFactory.create(topic=self.topic_2, poster=self.u1)
self.topic_3 = create_topic(forum=self.forum_2, poster=self.u1)
PostFactory.create(topic=self.topic_3, poster=self.u1)
self.topic_4 = create_topic(forum=self.forum_2, poster=self.user)
PostFactory.create(topic=self.topic_4, poster=self.user)
# Assign some permissions
assign_perm('can_read_forum', self.g1, self.top_level_cat_1)
assign_perm('can_read_forum', self.g1, self.forum_1)
assign_perm('can_read_forum', self.g1, self.forum_2)
def test_cannot_be_cleaned_if_the_anonymous_poster_username_is_not_specified(self):
# Run & check
with pytest.raises(ValidationError):
post = PostFactory.build(topic=self.topic, poster=None, anonymous_key='1234')
post.clean()
def test_has_a_first_post(self):
# Run & check
assert self.topic.first_post == self.post
PostFactory.create(topic=self.topic, poster=self.u1)
assert self.topic.first_post == self.post
def test_knows_if_it_is_the_topic_tail(self):
# Run & check
post = PostFactory.create(topic=self.topic, poster=self.u1)
assert post.is_topic_tail
def test_cannot_be_cleaned_if_it_is_not_associated_with_a_user_and_an_anonymous_user(self):
# Run & check
with pytest.raises(ValidationError):
post = PostFactory.build(topic=self.topic, poster=self.u1, anonymous_key='1234')
post.clean()
def test_send_auto_subscribe_posts(self, mailoutbox):
# Setup
u1 = UserFactory.create()
u2 = UserFactory.create()
top_level_forum = create_forum()
# Create a topic to auto create a forum profile
topic = create_topic(forum=top_level_forum, poster=u1)
PostFactory.create(topic=topic, poster=u1)
PostFactory.create(topic=topic, poster=u2)
# Verify this doesn't trigger a notification to u2
PostFactory.create(topic=topic, poster=u1)
call_command('send_notifications')
assert len(mailoutbox) == 0
profile = ForumProfile.objects.get(user=u2)
profile.notify_subscribed_topics = True
profile.auto_subscribe_posts = True
profile.save()
# Create the topic with a post
topic = create_topic(forum=top_level_forum, poster=u1)
PostFactory.create(topic=topic, poster=u1, notifications_sent=True)
# Create a post in a topic that u2 will subscribe to
PostFactory.create(topic=topic, poster=u2)
# Create a post to notify u2
PostFactory.create(topic=topic, poster=u1)
# Run & check
call_command('send_notifications')
assert len(mailoutbox) == 1
