class GalleryTest(TestCase):
def setUp(self):
self.profile = ProfileFactory()
self.gallery = GalleryFactory()
self.image1 = ImageFactory(gallery=self.gallery)
self.image2 = ImageFactory(gallery=self.gallery)
self.user_gallery = UserGalleryFactory(user=self.profile.user,
gallery=self.gallery)
def tearDown(self):
self.image1.delete()
self.image2.delete()
self.user_gallery.delete()
self.gallery.delete()
def test_get_absolute_url(self):
absolute_url = reverse("gallery-details",
args=[self.gallery.pk, self.gallery.slug])
self.assertEqual(absolute_url, self.gallery.get_absolute_url())
def test_get_linked_users(self):
self.assertEqual(1, len(self.gallery.get_linked_users()))
self.assertEqual(self.user_gallery, self.gallery.get_linked_users()[0])
def test_get_images(self):
self.assertEqual(2, len(self.gallery.get_images()))
self.assertEqual(self.image1, self.gallery.get_images()[0])
self.assertEqual(self.image2, self.gallery.get_images()[1])
def test_get_last_image(self):
self.assertEqual(self.image2, self.gallery.get_last_image())
def test_delete_empty_gallery(self):
test_gallery = GalleryFactory()
path = test_gallery.get_gallery_path()
test_gallery.delete()
self.assertFalse(os.path.isdir(path))
def test_delete_gallery_with_image(self):
test_gallery = GalleryFactory()
test_image = ImageFactory(gallery=test_gallery)
path_gallery = test_gallery.get_gallery_path()
self.assertTrue(os.path.isdir(path_gallery))
path_image = test_image.physical.path
self.assertTrue(os.path.isfile(path_image))
# Destroy the gallery and the image
test_gallery.delete()
self.assertFalse(os.path.isdir(path_gallery))
self.assertFalse(os.path.isfile(path_image))
def test_unregister(self):
"""
To test that unregistering user is working.
"""
# test not logged user can't unregister.
self.client.logout()
result = self.client.post(reverse("member-unregister"), follow=False)
self.assertEqual(result.status_code, 302)
# test logged user can unregister.
user = ProfileFactory()
self.client.force_login(user.user)
result = self.client.post(reverse("member-unregister"), follow=False)
self.assertEqual(result.status_code, 302)
self.assertEqual(User.objects.filter(username=user.user.username).count(), 0)
# Attach a user at tutorials, articles, topics and private topics. After that,
# unregister this user and check that he is well removed in all contents.
user = ProfileFactory()
user2 = ProfileFactory()
alone_gallery = GalleryFactory()
UserGalleryFactory(gallery=alone_gallery, user=user.user)
shared_gallery = GalleryFactory()
UserGalleryFactory(gallery=shared_gallery, user=user.user)
UserGalleryFactory(gallery=shared_gallery, user=user2.user)
# first case : a published tutorial with only one author
published_tutorial_alone = PublishedContentFactory(type="TUTORIAL")
published_tutorial_alone.authors.add(user.user)
published_tutorial_alone.save()
# second case : a published tutorial with two authors
published_tutorial_2 = PublishedContentFactory(type="TUTORIAL")
published_tutorial_2.authors.add(user.user)
published_tutorial_2.authors.add(user2.user)
published_tutorial_2.save()
# third case : a private tutorial with only one author
writing_tutorial_alone = PublishableContentFactory(type="TUTORIAL")
writing_tutorial_alone.authors.add(user.user)
writing_tutorial_alone.save()
writing_tutorial_alone_galler_path = writing_tutorial_alone.gallery.get_gallery_path()
# fourth case : a private tutorial with at least two authors
writing_tutorial_2 = PublishableContentFactory(type="TUTORIAL")
writing_tutorial_2.authors.add(user.user)
writing_tutorial_2.authors.add(user2.user)
writing_tutorial_2.save()
self.client.force_login(self.staff)
# same thing for articles
published_article_alone = PublishedContentFactory(type="ARTICLE")
published_article_alone.authors.add(user.user)
published_article_alone.save()
published_article_2 = PublishedContentFactory(type="ARTICLE")
published_article_2.authors.add(user.user)
published_article_2.authors.add(user2.user)
published_article_2.save()
writing_article_alone = PublishableContentFactory(type="ARTICLE")
writing_article_alone.authors.add(user.user)
writing_article_alone.save()
writing_article_2 = PublishableContentFactory(type="ARTICLE")
writing_article_2.authors.add(user.user)
writing_article_2.authors.add(user2.user)
writing_article_2.save()
# beta content
beta_forum = ForumFactory(category=ForumCategoryFactory())
beta_content = BetaContentFactory(author_list=[user.user], forum=beta_forum)
beta_content_2 = BetaContentFactory(author_list=[user.user, user2.user], forum=beta_forum)
# about posts and topics
authored_topic = TopicFactory(author=user.user, forum=self.forum11, solved_by=user.user)
answered_topic = TopicFactory(author=user2.user, forum=self.forum11)
PostFactory(topic=answered_topic, author=user.user, position=2)
edited_answer = PostFactory(topic=answered_topic, author=user.user, position=3)
edited_answer.editor = user.user
edited_answer.save()
upvoted_answer = PostFactory(topic=answered_topic, author=user2.user, position=4)
upvoted_answer.like += 1
upvoted_answer.save()
CommentVote.objects.create(user=user.user, comment=upvoted_answer, positive=True)
private_topic = PrivateTopicFactory(author=user.user)
private_topic.participants.add(user2.user)
private_topic.save()
PrivatePostFactory(author=user.user, privatetopic=private_topic, position_in_topic=1)
# add API key
self.assertEqual(Application.objects.count(), 0)
self.assertEqual(AccessToken.objects.count(), 0)
api_application = Application()
api_application.client_id = "foobar"
api_application.user = user.user
api_application.client_type = "confidential"
api_application.authorization_grant_type = "password"
api_application.client_secret = "42"
api_application.save()
token = AccessToken()
token.user = user.user
token.token = "r@d0m"
token.application = api_application
token.expires = datetime.now()
token.save()
self.assertEqual(Application.objects.count(), 1)
self.assertEqual(AccessToken.objects.count(), 1)
# add a karma note and a sanction with this user
note = KarmaNote(moderator=user.user, user=user2.user, note="Good!", karma=5)
note.save()
ban = Ban(moderator=user.user, user=user2.user, type="Ban définitif", note="Test")
ban.save()
# login and unregister:
self.client.force_login(user.user)
result = self.client.post(reverse("member-unregister"), follow=False)
self.assertEqual(result.status_code, 302)
# check that the bot have taken authorship of tutorial:
self.assertEqual(published_tutorial_alone.authors.count(), 1)
self.assertEqual(
published_tutorial_alone.authors.first().username, settings.ZDS_APP["member"]["external_account"]
)
self.assertFalse(os.path.exists(writing_tutorial_alone_galler_path))
self.assertEqual(published_tutorial_2.authors.count(), 1)
self.assertEqual(
published_tutorial_2.authors.filter(username=settings.ZDS_APP["member"]["external_account"]).count(), 0
)
# check that published tutorials remain published and accessible
self.assertIsNotNone(published_tutorial_2.public_version.get_prod_path())
self.assertTrue(os.path.exists(published_tutorial_2.public_version.get_prod_path()))
self.assertIsNotNone(published_tutorial_alone.public_version.get_prod_path())
self.assertTrue(os.path.exists(published_tutorial_alone.public_version.get_prod_path()))
self.assertEqual(
self.client.get(
reverse("tutorial:view", args=[published_tutorial_alone.pk, published_tutorial_alone.slug]),
follow=False,
).status_code,
200,
)
self.assertEqual(
self.client.get(
reverse("tutorial:view", args=[published_tutorial_2.pk, published_tutorial_2.slug]), follow=False
).status_code,
200,
)
# test that published articles remain accessible
self.assertTrue(os.path.exists(published_article_alone.public_version.get_prod_path()))
self.assertEqual(
self.client.get(
reverse("article:view", args=[published_article_alone.pk, published_article_alone.slug]), follow=True
).status_code,
200,
)
self.assertEqual(
self.client.get(
reverse("article:view", args=[published_article_2.pk, published_article_2.slug]), follow=True
).status_code,
200,
)
# check that the tutorial for which the author was alone does not exists anymore
self.assertEqual(PublishableContent.objects.filter(pk=writing_tutorial_alone.pk).count(), 0)
self.assertFalse(os.path.exists(writing_tutorial_alone.get_repo_path()))
# check that bot haven't take the authorship of the tuto with more than one author
self.assertEqual(writing_tutorial_2.authors.count(), 1)
self.assertEqual(
writing_tutorial_2.authors.filter(username=settings.ZDS_APP["member"]["external_account"]).count(), 0
)
# authorship for the article for which user was the only author
self.assertEqual(published_article_alone.authors.count(), 1)
self.assertEqual(
published_article_alone.authors.first().username, settings.ZDS_APP["member"]["external_account"]
)
self.assertEqual(published_article_2.authors.count(), 1)
self.assertEqual(PublishableContent.objects.filter(pk=writing_article_alone.pk).count(), 0)
self.assertFalse(os.path.exists(writing_article_alone.get_repo_path()))
# not bot if another author:
self.assertEqual(
published_article_2.authors.filter(username=settings.ZDS_APP["member"]["external_account"]).count(), 0
)
self.assertEqual(writing_article_2.authors.count(), 1)
self.assertEqual(
writing_article_2.authors.filter(username=settings.ZDS_APP["member"]["external_account"]).count(), 0
)
# topics, gallery and PMs:
self.assertEqual(Topic.objects.filter(author__username=user.user.username).count(), 0)
self.assertEqual(Topic.objects.filter(solved_by=user.user).count(), 0)
self.assertEqual(Topic.objects.filter(solved_by=self.anonymous).count(), 1)
self.assertEqual(Post.objects.filter(author__username=user.user.username).count(), 0)
self.assertEqual(Post.objects.filter(editor__username=user.user.username).count(), 0)
self.assertEqual(PrivatePost.objects.filter(author__username=user.user.username).count(), 0)
self.assertEqual(PrivateTopic.objects.filter(author__username=user.user.username).count(), 0)
self.assertIsNotNone(Topic.objects.get(pk=authored_topic.pk))
self.assertIsNotNone(PrivateTopic.objects.get(pk=private_topic.pk))
self.assertIsNotNone(Gallery.objects.get(pk=alone_gallery.pk))
self.assertEqual(alone_gallery.get_linked_users().count(), 1)
self.assertEqual(shared_gallery.get_linked_users().count(), 1)
self.assertEqual(UserGallery.objects.filter(user=user.user).count(), 0)
self.assertEqual(CommentVote.objects.filter(user=user.user, positive=True).count(), 0)
self.assertEqual(Post.objects.filter(pk=upvoted_answer.id).first().like, 0)
# zep 12, published contents and beta
self.assertIsNotNone(PublishedContent.objects.filter(content__pk=published_tutorial_alone.pk).first())
self.assertIsNotNone(PublishedContent.objects.filter(content__pk=published_tutorial_2.pk).first())
self.assertTrue(Topic.objects.get(pk=beta_content.beta_topic.pk).is_locked)
self.assertFalse(Topic.objects.get(pk=beta_content_2.beta_topic.pk).is_locked)
# check API
self.assertEqual(Application.objects.count(), 0)
self.assertEqual(AccessToken.objects.count(), 0)
# check that the karma note and the sanction were kept
self.assertTrue(KarmaNote.objects.filter(pk=note.pk).exists())
self.assertTrue(Ban.objects.filter(pk=ban.pk).exists())