def setUp(self):
self.overridden_zds_app = overridden_zds_app
# don't build PDF to speed up the tests
overridden_zds_app["content"]["build_pdf_when_published"] = False
self.staff = StaffProfileFactory().user
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
overridden_zds_app["member"]["bot_account"] = self.mas.username
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory(category=CategoryFactory())
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
self.content = PublishableContentFactory(
author_list=[self.user_author], light=False)
self.part_published = ContainerFactory(
db_object=self.content,
light=False,
parent=self.content.load_version())
self.ignored_part = ContainerFactory(
db_object=self.content,
light=False,
parent=self.content.load_version())
ExtractFactory(db_object=self.content,
container=self.part_published,
light=False)
ExtractFactory(db_object=self.content,
container=self.ignored_part,
light=False)
def setUp(self):
self.overridden_zds_app = overridden_zds_app
# don't build PDF to speed up the tests
overridden_zds_app["content"]["build_pdf_when_published"] = False
self.staff = StaffProfileFactory().user
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
overridden_zds_app["member"]["bot_account"] = self.mas.username
bot = Group(name=overridden_zds_app["member"]["bot_group"])
bot.save()
self.external = UserFactory(
username=overridden_zds_app["member"]["external_account"],
password="******")
self.beta_forum = ForumFactory(
pk=overridden_zds_app["forum"]["beta_forum_id"],
category=ForumCategoryFactory(position=1),
position_in_category=1,
) # ensure that the forum, for the beta versions, is created
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory()
self.tag = TagFactory()
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
# create an article
self.article = PublishableContentFactory(type="ARTICLE")
self.article.authors.add(self.user_author)
UserGalleryFactory(gallery=self.article.gallery,
user=self.user_author,
mode="W")
self.article.licence = self.licence
self.article.subcategory.add(self.subcategory)
self.article.tags.add(self.tag)
self.article.save()
# fill it with one extract
self.article_draft = self.article.load_version()
self.extract1 = ExtractFactory(container=self.article_draft,
db_object=self.article)
# then, publish it !
version = self.article_draft.current_version
self.published = publish_content(self.article,
self.article_draft,
is_major_update=True)
self.article.sha_public = version
self.article.sha_draft = version
self.article.public_version = self.published
self.article.save()
self.articlefeed = LastArticlesFeedRSS()
def setUp(self):
self.user1 = ProfileFactory()
self.staff = StaffProfileFactory()
# Create a forum for later test
self.forumcat = ForumCategoryFactory()
self.forum = ForumFactory(category=self.forumcat)
self.forumtopic = TopicFactory(forum=self.forum,
author=self.staff.user)
def load_staff(cli, size, fake, root, *_):
"""
Load staff
"""
nb_staffs = size * 3
cli.stdout.write(f"Nombres de staffs à créer : {nb_staffs}")
tps1 = time.time()
cpt = 1
for i in range(0, nb_staffs):
while Profile.objects.filter(user__username=f"{root}staff{cpt}").count() > 0:
cpt += 1
profile = StaffProfileFactory(user__username=f"{root}staff{cpt}")
profile.user.first_name = fake.first_name()
profile.user.last_name = fake.last_name()
profile.user.email = fake.free_email()
profile.user.save()
profile.site = fake.url()
profile.biography = fake.paragraph()
profile.sign = fake.text(max_nb_chars=80)
profile.last_ip_address = fake.ipv6()
profile.save()
cpt += 1
sys.stdout.write(f" Staff {i + 1}/{nb_staffs} \r")
sys.stdout.flush()
tps2 = time.time()
cli.stdout.write(f"\nFait en {tps2 - tps1} sec")
def setUp(self):
self.user1 = ProfileFactory().user
self.user2 = ProfileFactory().user
self.to_be_changed_staff = StaffProfileFactory().user
self.staff = StaffProfileFactory().user
self.assertTrue(self.staff.has_perm("forum.change_topic"))
self.category1 = ForumCategoryFactory(position=1)
self.forum11 = ForumFactory(category=self.category1,
position_in_category=1)
self.forum12 = ForumFactory(category=self.category1,
position_in_category=2)
for group in self.staff.groups.all():
self.forum12.groups.add(group)
self.forum12.save()
def test_failure_too_long_url(self):
staff = StaffProfileFactory()
self.client.force_login(staff.user)
self.assertEqual(0, FeaturedResource.objects.all().count())
response = self.client.post(
reverse("featured-resource-create"),
{
"title": "title",
"type": "type",
"image_url": stringof2001chars,
"url": "http://test.com",
"authors": staff.user.username,
},
follow=True,
)
self.assertEqual(200, response.status_code)
self.assertEqual(0, FeaturedResource.objects.all().count())
response = self.client.post(
reverse("featured-resource-create"),
{
"title": "title",
"type": "type",
"image_url": "http://test.com/image.png",
"url": stringof2001chars,
"authors": staff.user.username,
},
follow=True,
)
self.assertEqual(200, response.status_code)
self.assertEqual(0, FeaturedResource.objects.all().count())
def test_success_list(self):
staff = StaffProfileFactory()
self.client.force_login(staff.user)
response = self.client.get(reverse("featured-resource-requests"))
self.assertEqual(200, response.status_code)
def test_create_only_one_message_in_system(self):
staff = StaffProfileFactory()
self.client.force_login(staff.user)
response = self.client.post(
reverse("featured-message-create"),
{
"message": "message",
"url": "http://test.com",
},
follow=True,
)
self.assertEqual(200, response.status_code)
self.assertEqual(1, FeaturedMessage.objects.count())
response = self.client.post(
reverse("featured-message-create"),
{
"message": "message",
"url": "http://test.com",
},
follow=True,
)
self.assertEqual(200, response.status_code)
self.assertEqual(1, FeaturedMessage.objects.count())
def test_hide_post_mark_notification_as_read(self):
"""
Ensure a notification gets deleted when the corresponding post is hidden.
"""
topic = TopicFactory(forum=self.forum11, author=self.user1)
PostFactory(topic=topic, author=self.user1, position=1)
PostFactory(topic=topic, author=self.user2, position=2)
PostFactory(topic=topic, author=ProfileFactory().user, position=3)
notifications = Notification.objects.filter(
object_id=topic.last_message.pk, is_read=False).all()
self.assertEqual(1, len(notifications))
# hide last post
data = {"delete_message": ""}
self.client.force_login(StaffProfileFactory().user)
response = self.client.post(reverse("post-edit") +
f"?message={topic.last_message.pk}",
data,
follow=False)
self.assertEqual(302, response.status_code)
notifications = Notification.objects.filter(
object_id=topic.last_message.pk, is_read=True).all()
self.assertEqual(1, len(notifications))
def test_forbidden_email_provider_user_form(self):
moderator = StaffProfileFactory().user
if not BannedEmailProvider.objects.filter(provider="yopmail.com").exists():
BannedEmailProvider.objects.create(provider="yopmail.com", moderator=moderator)
data = {"username": self.user1.user.username, "email": "*****@*****.**"}
form = ChangeUserForm(data=data, user=self.user1.user)
self.assertFalse(form.is_valid())
def setUp(self):
# Create users
self.author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.outsider = ProfileFactory().user
self.contributor = ProfileFactory().user
# Create a contribution role
self.role = create_role("Validateur")
# Create content
self.content = PublishableContentFactory(author_list=[self.author])
self.contribution = create_contribution(self.role, self.contributor,
self.content)
# Get information to be reused in tests
self.form_url = reverse("content:remove-contributor",
kwargs={"pk": self.content.pk})
self.login_url = reverse("member-login") + "?next=" + self.form_url
self.content_url = reverse("content:view",
kwargs={
"pk": self.content.pk,
"slug": self.content.slug
})
self.form_data = {"pk_contribution": self.contribution.pk}
def test_failed_bot_sanctions(self):
staff = StaffProfileFactory()
self.client.force_login(staff.user)
bot_profile = ProfileFactory()
bot_profile.user.groups.add(self.bot)
bot_profile.user.save()
# Test: LS
result = self.client.post(
reverse("member-modify-profile",
kwargs={"user_pk": bot_profile.user.id}),
{
"ls": "",
"ls-text": "Texte de test pour LS"
},
follow=False,
)
user = Profile.objects.get(
id=bot_profile.id) # Refresh profile from DB
self.assertEqual(result.status_code, 403)
self.assertTrue(user.can_write)
self.assertTrue(user.can_read)
self.assertIsNone(user.end_ban_write)
self.assertIsNone(user.end_ban_read)
def test_move_topic_from_forum_followed_to_forum_followed_too(self):
NewTopicSubscription.objects.toggle_follow(self.forum11, self.user1)
NewTopicSubscription.objects.toggle_follow(self.forum12, self.user1)
topic = TopicFactory(forum=self.forum11, author=self.user2)
PostFactory(topic=topic, author=self.user2, position=1)
self.assertEqual(1, len(Notification.objects.filter(object_id=topic.pk, is_read=False).all()))
# Move the topic to another forum.
self.client.logout()
staff = StaffProfileFactory()
self.client.force_login(staff.user)
data = {"move": "", "forum": self.forum12.pk, "topic": topic.pk}
response = self.client.post(reverse("topic-edit"), data, follow=False)
self.assertEqual(302, response.status_code)
topic = Topic.objects.get(pk=topic.pk)
self.assertEqual(self.forum12, topic.forum)
self.assertEqual(1, len(Notification.objects.filter(object_id=topic.pk, is_read=False, is_dead=False).all()))
self.client.logout()
self.client.force_login(self.user1)
response = self.client.get(reverse("topic-posts-list", args=[topic.pk, topic.slug()]))
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(Notification.objects.filter(object_id=topic.pk, is_read=True, is_dead=False).all()))
def test_subscription_deactivated_and_notification_read_when_topic_moved(self):
"""
When a topic is moved to a forum where subscribers can't read it, the subscriptions
should be deactivated and notifications marked as read.
"""
topic = TopicFactory(forum=self.forum11, author=self.user1)
PostFactory(topic=topic, author=self.user1, position=1)
other_user = ProfileFactory().user
TopicAnswerSubscription.objects.toggle_follow(topic, other_user)
PostFactory(topic=topic, author=ProfileFactory().user, position=2)
self.assertIsNotNone(TopicAnswerSubscription.objects.get_existing(self.user1, topic, is_active=True))
self.assertIsNotNone(Notification.objects.get(subscription__user=self.user1, is_read=False))
forum_not_read = ForumFactory(category=self.category1, position_in_category=2)
forum_not_read.groups.add(Group.objects.create(name="DummyGroup_1"))
self.client.force_login(StaffProfileFactory().user)
data = {"move": "", "forum": forum_not_read.pk, "topic": topic.pk}
response = self.client.post(reverse("topic-edit"), data, follow=False)
self.assertEqual(302, response.status_code)
self.assertIsNotNone(TopicAnswerSubscription.objects.get_existing(self.user1, topic, is_active=False))
self.assertIsNotNone(Notification.objects.get(subscription__user=self.user1, is_read=True))
self.assertFalse(TopicAnswerSubscription.objects.get_existing(other_user, topic).is_active)
self.assertIsNotNone(Notification.objects.get(subscription__user=other_user, is_read=True))
def setUp(self):
# Create users
self.author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.outsider = ProfileFactory().user
self.contributor = ProfileFactory().user
settings.ZDS_APP["member"]["bot_account"] = ProfileFactory(
).user.username
# Create content
self.content = PublishableContentFactory(author_list=[self.author])
self.role = create_role("Contributeur espiègle")
# Get information to be reused in tests
self.form_url = reverse("content:add-contributor",
kwargs={"pk": self.content.pk})
self.login_url = reverse("member-login") + "?next=" + self.form_url
self.content_url = reverse("content:view",
kwargs={
"pk": self.content.pk,
"slug": self.content.slug
})
self.form_data = {
"username": self.contributor,
"contribution_role": self.role.pk
}
def setUp(self):
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
self.overridden_zds_app["member"]["bot_account"] = self.mas.username
self.licence = LicenceFactory()
self.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type="TUTORIAL")
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery,
user=self.user_author,
mode="W")
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft,
db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1,
db_object=self.tuto)
self.extract1 = ExtractFactory(container=self.chapter1,
db_object=self.tuto)
def setUp(self):
# Create users
self.staff = StaffProfileFactory().user
self.author = ProfileFactory().user
# Createcontents
self.content = PublishableContentFactory(author_list=[self.author])
self.suggestable_content_1 = PublishedContentFactory()
self.suggestable_content_2 = PublishedContentFactory()
self.unpublished_content = PublishableContentFactory()
self.not_picked_opinion = PublishedContentFactory()
self.not_picked_opinion.type = "OPINION"
self.not_picked_opinion.save()
# Get information to be reused in tests
self.form_url = reverse("content:add-suggestion",
kwargs={"pk": self.content.pk})
self.success_message_fragment = _("a été ajouté dans les suggestions")
self.error_message_fragment_unpublished = _(
"un contenu qui n'a pas été publié")
self.error_message_fragment_already_suggested = _(
"fait déjà partie des suggestions de")
self.error_message_fragment_self = _(
"en tant que suggestion pour lui même")
self.error_messge_fragment_not_picked = _(
"un billet qui n'a pas été mis en avant")
# Log in with an authorized user to perform the tests
self.client.force_login(self.staff)
def test_failure_initial_content_not_found(self):
staff = StaffProfileFactory()
self.client.force_login(staff.user)
response = self.client.get(
"{}?content_type=published_content&content_id=42".format(reverse("featured-resource-create"))
)
self.assertContains(response, _("Le contenu est introuvable"))
def setUp(self):
self.overridden_zds_app["member"]["bot_account"] = ProfileFactory().user.username
self.licence = LicenceFactory()
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
def setUp(self):
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
settings.ZDS_APP["member"]["bot_account"] = self.mas.username
self.category, self.forum = create_category_and_forum()
self.user = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.manager = ESIndexManager(**settings.ES_SEARCH_INDEX)
self.indexable = [FakeChapter, PublishedContent, Topic, Post]
self.manager.reset_es_index(self.indexable)
self.manager.setup_custom_analyzer()
self.manager.refresh_index()
def setUp(self):
self.nb_part = 1
self.nb_chapter = 3
self.nb_section = 1
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
self.published = self.get_published_content(
self.user_author, self.user_staff, self.nb_part, self.nb_chapter, self.nb_section
)
def test_success_delete_featured(self):
staff = StaffProfileFactory()
self.client.force_login(staff.user)
news = FeaturedResourceFactory()
self.assertEqual(1, FeaturedResource.objects.all().count())
response = self.client.post(reverse("featured-resource-delete", args=[news.pk]), follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual(0, FeaturedResource.objects.filter(pk=news.pk).count())
def setUp(self):
self.staff = StaffProfileFactory().user
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
self.overridden_zds_app["member"]["bot_account"] = self.mas.username
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory()
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
self.tuto = PublishableContentFactory(type="TUTORIAL")
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery,
user=self.user_author,
mode="W")
self.tuto.licence = self.licence
self.tuto.subcategory.add(self.subcategory)
self.tuto.save()
self.beta_forum = ForumFactory(
pk=self.overridden_zds_app["forum"]["beta_forum_id"],
category=ForumCategoryFactory(position=1),
position_in_category=1,
) # ensure that the forum, for the beta versions, is created
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft,
db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1,
db_object=self.tuto)
self.extract1 = ExtractFactory(container=self.chapter1,
db_object=self.tuto)
bot = Group(name=self.overridden_zds_app["member"]["bot_group"])
bot.save()
self.external = UserFactory(
username=self.overridden_zds_app["member"]["external_account"],
password="******")
def setUp(self):
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
settings.ZDS_APP["member"]["bot_account"] = self.mas.username
self.category, self.forum = create_category_and_forum()
self.user = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.index_manager = ESIndexManager(**settings.ES_SEARCH_INDEX)
def setUp(self):
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory()
settings.ZDS_APP["member"]["bot_account"] = self.mas.user.username
self.anonymous = UserFactory(username=settings.ZDS_APP["member"]["anonymous_account"], password="******")
self.external = UserFactory(username=settings.ZDS_APP["member"]["external_account"], password="******")
self.category1 = ForumCategoryFactory(position=1)
self.forum11 = ForumFactory(category=self.category1, position_in_category=1)
self.staff = StaffProfileFactory().user
self.bot = Group(name=settings.ZDS_APP["member"]["bot_group"])
self.bot.save()
def test_forbidden_email_provider_register_form(self):
moderator = StaffProfileFactory().user
if not BannedEmailProvider.objects.filter(provider="yopmail.com").exists():
BannedEmailProvider.objects.create(provider="yopmail.com", moderator=moderator)
data = {
"email": "*****@*****.**",
"username": "******",
"password": "******",
"password_confirm": "ZePassword",
}
form = RegisterForm(data=data)
self.assertFalse(form.is_valid())
def test_request_content_exports_generation(self):
author = ProfileFactory()
not_author = ProfileFactory()
staff = StaffProfileFactory()
content = PublishedContentFactory(
author_list=[author.user]).public_version
self.assertEqual(
0,
PublicationEvent.objects.filter(published_object=content).count())
# Anonymous sender should not be able to ask for exports generation
response = self.client.post(
reverse("api:content:generate_export", args=[content.content.pk]))
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(
0,
PublicationEvent.objects.filter(published_object=content).count())
# An authenticated author but not an author should not either
self.client.force_login(not_author.user)
response = self.client.post(
reverse("api:content:generate_export", args=[content.content.pk]))
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(
0,
PublicationEvent.objects.filter(published_object=content).count())
# But if the user is staff, it should
self.client.force_login(staff.user)
response = self.client.post(
reverse("api:content:generate_export", args=[content.content.pk]))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
requests_count = PublicationEvent.objects.filter(
published_object=content).count()
self.assertGreater(requests_count, 0)
# And if the user is an author, it should too
self.client.force_login(author.user)
response = self.client.post(
reverse("api:content:generate_export", args=[content.content.pk]))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# And it should be greater than the previous one as we added new requets
self.assertGreater(
PublicationEvent.objects.filter(published_object=content).count(),
requests_count)
self.client.logout()
def setUp(self):
# Create users
self.author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.outsider = ProfileFactory().user
# Create a content
self.content = PublishableContentFactory(author_list=[self.author])
# Get information to be reused in tests
self.events_list_url = reverse("content:events",
kwargs={"pk": self.content.pk})
self.login_url = reverse(
"member-login") + "?next=" + self.events_list_url
def test_filter_member_ip(self):
"""
Test filter member by ip.
"""
# create users (one regular and one staff and superuser)
tester = ProfileFactory()
staff = StaffProfileFactory()
# test login normal user
result = self.client.post(
reverse("member-login"),
{
"username": tester.user.username,
"password": "******",
"remember": "remember"
},
follow=False,
)
# good password then redirection
self.assertEqual(result.status_code, 302)
# Check that the filter can't be access from normal user
result = self.client.post(
reverse("member-from-ip",
kwargs={"ip_address": tester.last_ip_address}), {},
follow=False)
self.assertEqual(result.status_code, 403)
# log the staff user
result = self.client.post(
reverse("member-login"),
{
"username": staff.user.username,
"password": "******",
"remember": "remember"
},
follow=False,
)
# good password then redirection
self.assertEqual(result.status_code, 302)
# test that we retrieve correctly the 2 members (staff + user) from this ip
result = self.client.post(
reverse("member-from-ip",
kwargs={"ip_address": staff.last_ip_address}), {},
follow=False)
self.assertEqual(result.status_code, 200)
self.assertEqual(len(result.context["members"]), 2)
def setUp(self):
self.user = ProfileFactory().user
self.staff = StaffProfileFactory().user
_, forum = create_category_and_forum()
topic = create_topic_in_forum(forum, self.user.profile)
self.client.force_login(self.user)
data = {"text": "A new post!"}
self.client.post(reverse("post-edit") +
f"?message={topic.last_message.pk}",
data,
follow=False)
self.post = topic.last_message
self.edit = CommentEdit.objects.latest("date")
