def setUp(self): self.profile = ProfileFactory() self.other = ProfileFactory() self.new_participant = ProfileFactory() self.client = APIClient() client_oauth2 = create_oauth2_client(self.profile.user) authenticate_client(self.client, client_oauth2, self.profile.user.username, "hostel77") self.gallery = GalleryFactory() UserGalleryFactory(user=self.profile.user, gallery=self.gallery) self.image = ImageFactory(gallery=self.gallery) self.gallery_other = GalleryFactory() UserGalleryFactory(user=self.other.user, gallery=self.gallery_other) self.image_other = ImageFactory(gallery=self.gallery_other) self.gallery_shared = GalleryFactory() UserGalleryFactory(user=self.other.user, gallery=self.gallery_shared) UserGalleryFactory(user=self.profile.user, gallery=self.gallery_shared, mode=GALLERY_READ) self.image_shared = ImageFactory(gallery=self.gallery_shared) tuto = PublishableContentFactory( type="TUTORIAL", author_list=[self.profile.user, self.new_participant.user]) self.gallery_tuto = tuto.gallery
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): self.user1 = ProfileFactory().user self.user1.profile.email_for_answer = True self.user1.profile.email_for_new_mp = False self.user1.profile.save() self.user2 = ProfileFactory().user self.user2.profile.email_for_answer = True self.user2.profile.email_for_new_mp = False self.user2.profile.save() self.user3 = ProfileFactory().user self.user3.profile.email_for_answer = True self.user3.profile.email_for_new_mp = True self.user3.profile.save() self.user4 = ProfileFactory().user self.user4.profile.email_for_answer = False self.user4.profile.email_for_new_mp = False self.user4.profile.save() self.user5 = ProfileFactory().user self.user5.profile.email_for_answer = False self.user5.profile.email_for_new_mp = True self.user5.profile.save() # Login as profile1 self.client.force_login(self.user1) # Save bot group bot = Group(name=settings.ZDS_APP["member"]["bot_group"]) bot.save()
class SetLastVisitMiddlewareTest(TestCase): def setUp(self): self.user = ProfileFactory() def test_process_response(self): profile_pk = self.user.pk # login self.client.force_login(self.user.user) # set last login to a recent date self.user.last_visit = datetime.now() - timedelta(seconds=10) self.user.save() # load a page self.client.get(reverse("homepage")) # the date of last visit should not have been updated profile = get_object_or_404(Profile, pk=profile_pk) self.assertTrue( datetime.now() - profile.last_visit > timedelta(seconds=5)) # set last login to an old date self.user.last_visit = datetime.now() - timedelta(seconds=45) self.user.save() # load a page self.client.get(reverse("homepage")) # the date of last visit should have been updated profile = get_object_or_404(Profile, pk=profile_pk) self.assertTrue( datetime.now() - profile.last_visit < timedelta(seconds=5))
def test_remove_hat(self): hat_name = "A hat" profile = ProfileFactory() user = profile.user # add a hat with a staff member self.client.force_login(self.staff) self.client.post(reverse("add-hat", args=[user.pk]), {"hat": hat_name}, follow=False) self.assertIn(hat_name, profile.hats.values_list("name", flat=True)) hat = Hat.objects.get(name=hat_name) # test that this option is not available for an other user self.client.force_login(ProfileFactory().user) result = self.client.post(reverse("remove-hat", args=[user.pk, hat.pk]), follow=False) self.assertEqual(result.status_code, 403) self.assertIn(hat, profile.hats.all()) # but check that it works for the user having the hat self.client.force_login(user) result = self.client.post(reverse("remove-hat", args=[user.pk, hat.pk]), follow=False) self.assertEqual(result.status_code, 302) self.assertNotIn(hat, profile.hats.all()) # test that it works for a staff member profile.hats.add(hat) # we have to add the hat again for this test self.client.force_login(self.staff) result = self.client.post(reverse("remove-hat", args=[user.pk, hat.pk]), follow=False) self.assertEqual(result.status_code, 302) self.assertNotIn(hat, profile.hats.all()) # but check that the hat still exists in database self.assertTrue(Hat.objects.filter(name=hat_name).exists())
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 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.gallery = GalleryFactory() self.profile1 = ProfileFactory() self.profile2 = ProfileFactory() self.profile3 = ProfileFactory() self.user_gallery1 = UserGalleryFactory(user=self.profile1.user, gallery=self.gallery, mode="W") self.user_gallery2 = UserGalleryFactory(user=self.profile2.user, gallery=self.gallery, mode="R")
def test_profile_page_of_weird_member_username(self): # create some user with weird username user_1 = ProfileFactory() user_2 = ProfileFactory() user_3 = ProfileFactory() user_1.user.username = "******" user_1.user.save() user_2.user.username = "******" user_2.user.save() user_3.user.username = "******" user_3.user.save() # profile pages of weird users. result = self.client.get(reverse("member-detail", args=[user_1.user.username]), follow=True) self.assertEqual(result.status_code, 200) result = self.client.get(reverse("member-detail", args=[user_2.user.username]), follow=True) self.assertEqual(result.status_code, 200) result = self.client.get(reverse("member-detail", args=[user_3.user.username]), follow=True) self.assertEqual(result.status_code, 200)
def test_hat_request_detail(self): hat_name = "A hat" # ask for a hat profile = ProfileFactory() self.client.force_login(profile.user) result = self.client.post( reverse("hats-settings"), { "hat": hat_name, "reason": "test", }, follow=False, ) self.assertEqual(result.status_code, 302) request = HatRequest.objects.latest("date") # test this page is available for the request author result = self.client.get(request.get_absolute_url()) self.assertEqual(result.status_code, 200) # test it's not available for another user other_user = ProfileFactory().user self.client.force_login(other_user) result = self.client.get(request.get_absolute_url()) self.assertEqual(result.status_code, 403) # login as staff self.client.force_login(self.staff) # test the page works result = self.client.get(request.get_absolute_url()) self.assertEqual(result.status_code, 200) self.assertContains(result, hat_name) self.assertContains(result, profile.user.username) self.assertContains(result, request.reason)
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): self.user1 = ProfileFactory().user self.user2 = ProfileFactory().user # create a tutorial self.tuto = PublishableContentFactory(type="TUTORIAL") self.tuto.authors.add(self.user1) UserGalleryFactory(gallery=self.tuto.gallery, user=self.user1, mode="W") self.tuto.licence = LicenceFactory() self.tuto.subcategory.add(SubCategoryFactory()) self.tuto.save() tuto_draft = self.tuto.load_version() # then, publish it ! version = tuto_draft.current_version self.published = publish_content(self.tuto, tuto_draft, is_major_update=True) self.tuto.sha_public = version self.tuto.sha_draft = version self.tuto.public_version = self.published self.tuto.save() self.client.force_login(self.user1)
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): 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 test_edit_with_more_than_max_ping(self): overridden_zds_app["comment"]["max_pings"] = 2 pinged_users = [ ProfileFactory(), ProfileFactory(), ProfileFactory(), ProfileFactory() ] self.client.force_login(self.user2) self.client.post( reverse("topic-new") + f"?forum={self.forum11.pk}", { "title": "Super sujet", "subtitle": "Pour tester les notifs", "text": "@{} @{} are pinged, not @{} @{}".format( *[a.user.username for a in pinged_users]), "tags": "", }, follow=False, ) topic = Topic.objects.last() post = topic.last_message self.assertEqual(2, PingSubscription.objects.count()) self.assertTrue( PingSubscription.objects.get_existing(pinged_users[0].user, post, True)) self.assertTrue( PingSubscription.objects.get_existing(pinged_users[1].user, post, True)) self.assertFalse( PingSubscription.objects.get_existing(pinged_users[2].user, post, True)) self.assertFalse( PingSubscription.objects.get_existing(pinged_users[3].user, post, True)) self.client.post( reverse("topic-edit") + f"?topic={topic.pk}", { "title": "Super sujet", "subtitle": "Pour tester les notifs", "text": f"@{pinged_users[1].user.username} @{pinged_users[3].user.username} are pinged", "tags": "", }, follow=False, ) self.assertTrue( PingSubscription.objects.get_existing(pinged_users[3].user, post, True)) self.assertTrue( PingSubscription.objects.get_existing(pinged_users[1].user, post, True)) self.assertFalse( PingSubscription.objects.get_existing(pinged_users[0].user, post, True))
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 test_success_reaction_karma_like(self): author = ProfileFactory() reaction = ContentReactionFactory(author=author.user, position=1, related_content=self.content) profile = ProfileFactory() self.client.force_login(profile.user) response = self.client.put(reverse("api:content:reaction-karma", args=(reaction.pk,)), {"vote": "like"}) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue(CommentVote.objects.filter(user=profile.user, comment=reaction, positive=True).exists())
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)
class SubscriptionsTest(TestCase): def setUp(self): self.userStandard1 = ProfileFactory(email_for_answer=True, email_for_new_mp=True).user self.userOAuth1 = ProfileFactory(email_for_answer=True, email_for_new_mp=True).user self.userOAuth2 = ProfileFactory(email_for_answer=True, email_for_new_mp=True).user self.userOAuth1.email = "" self.userOAuth2.email = "this is not an email" self.userOAuth1.save() self.userOAuth2.save() def test_no_emails_for_those_who_have_none(self): """ Test that we do not try to send e-mails to those who have not registered one. """ self.assertEqual(0, len(mail.outbox)) topic = send_mp( author=self.userStandard1, users=[self.userOAuth1], title="Testing", subtitle="", text="", send_by_mail=True, leave=False, ) self.assertEqual(0, len(mail.outbox)) send_message_mp(self.userOAuth1, topic, "", send_by_mail=True) self.assertEqual(1, len(mail.outbox)) def test_no_emails_for_those_who_have_other_things_in_that_place(self): """ Test that we do not try to send e-mails to those who have not registered a valid one. """ self.assertEqual(0, len(mail.outbox)) topic = send_mp( author=self.userStandard1, users=[self.userOAuth2], title="Testing", subtitle="", text="", send_by_mail=True, leave=False, ) self.assertEqual(0, len(mail.outbox)) send_message_mp(self.userOAuth2, topic, "", send_by_mail=True) self.assertEqual(1, len(mail.outbox))
def test_new_cowritten_content_without_doubly_notif(self): author1 = ProfileFactory() author2 = ProfileFactory() NewPublicationSubscription.objects.toggle_follow(author2.user, author1.user) content = PublishedContentFactory(author_list=[author1.user, author2.user]) signals.content_published.send(sender=content.__class__, instance=content, by_email=False) auto_user_1_sub = NewPublicationSubscription.objects.get_existing(author1.user, author1.user, False) self.assertIsNotNone(auto_user_1_sub) notifs = list(Notification.objects.get_notifications_of(author1.user)) self.assertEqual(1, len(notifs))
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 setUp(self): self.profile1 = ProfileFactory() self.profile2 = ProfileFactory() bot = Group(name=settings.ZDS_APP["member"]["bot_group"]) bot.save() self.hat, _ = Hat.objects.get_or_create(name__iexact="A hat", defaults={"name": "A hat"}) self.profile1.hats.add(self.hat) self.client.force_login(self.profile1.user)
def test_success_post_karma_dislike(self): profile = ProfileFactory() category, forum = create_category_and_forum() topic = create_topic_in_forum(forum, profile) another_profile = ProfileFactory() post = PostFactory(topic=topic, author=another_profile.user, position=2) self.client.force_login(profile.user) response = self.client.put(reverse("api:forum:post-karma", args=(post.pk,)), {"vote": "dislike"}) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue(CommentVote.objects.filter(user=profile.user, comment=post, positive=False).exists())
def test_profiler(self): result = self.client.get("/?prof", follow=True) self.assertEqual(result.status_code, 200) admin = ProfileFactory() admin.user.is_superuser = True admin.save() self.client.force_login(admin.user) result = self.client.get("/?prof", follow=True) self.assertEqual(result.status_code, 200)
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): self.user1 = ProfileFactory().user self.user2 = ProfileFactory().user self.user3 = ProfileFactory().user self.user1.profile.email_for_new_mp = True self.user2.profile.email_for_new_mp = True self.user3.profile.email_for_new_mp = False self.user1.profile.save() self.user2.profile.save() self.user3.profile.save() self.client.force_login(self.user1)
def setUp(self): self.user1 = ProfileFactory().user self.user2 = ProfileFactory().user 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) self.tag1 = TagFactory(title="Linux") self.tag2 = TagFactory(title="Windows") self.client.force_login(self.user1)
def setUp(self): self.profile1 = ProfileFactory() self.profile2 = ProfileFactory() self.profile3 = ProfileFactory() self.gallery1 = GalleryFactory() self.gallery2 = GalleryFactory() self.image1 = ImageFactory(gallery=self.gallery1) self.image2 = ImageFactory(gallery=self.gallery1) self.image3 = ImageFactory(gallery=self.gallery2) self.user_gallery1 = UserGalleryFactory(user=self.profile1.user, gallery=self.gallery1) self.user_gallery2 = UserGalleryFactory(user=self.profile1.user, gallery=self.gallery2) self.user_gallery3 = UserGalleryFactory(user=self.profile2.user, gallery=self.gallery1, mode="R")
def setUp(self): self.profile1 = ProfileFactory() self.profile2 = ProfileFactory() self.topic1 = PrivateTopicFactory(author=self.profile1.user) self.topic1.participants.add(self.profile2.user) self.post1 = PrivatePostFactory(privatetopic=self.topic1, author=self.profile1.user, position_in_topic=1) self.post2 = PrivatePostFactory(privatetopic=self.topic1, author=self.profile2.user, position_in_topic=2)
def setUp(self): self.userStandard1 = ProfileFactory(email_for_answer=True, email_for_new_mp=True).user self.userOAuth1 = ProfileFactory(email_for_answer=True, email_for_new_mp=True).user self.userOAuth2 = ProfileFactory(email_for_answer=True, email_for_new_mp=True).user self.userOAuth1.email = "" self.userOAuth2.email = "this is not an email" self.userOAuth1.save() self.userOAuth2.save()