def setUp(self):
settings.EMAIL_BACKEND = \
'django.core.mail.backends.locmem.EmailBackend'
self.category1 = CategoryFactory(position=1)
self.category2 = CategoryFactory(position=2)
self.category3 = CategoryFactory(position=3)
self.forum11 = ForumFactory(category=self.category1,
position_in_category=1)
self.forum12 = ForumFactory(category=self.category1,
position_in_category=2)
self.forum13 = ForumFactory(category=self.category1,
position_in_category=3)
self.forum21 = ForumFactory(category=self.category2,
position_in_category=1)
self.forum22 = ForumFactory(category=self.category2,
position_in_category=2)
self.user = ProfileFactory().user
self.user2 = ProfileFactory().user
log = self.client.login(username=self.user.username,
password='******')
self.assertEqual(log, True)
settings.ZDS_APP['member']['bot_account'] = ProfileFactory(
).user.username
def load_categories_forum(cli, size, fake):
"""
Load categories
"""
nb_categories = size * 2
cli.stdout.write(u"Nombres de catégories de forum à créer : {}".format(nb_categories))
tps1 = time.time()
for i in range(0, nb_categories):
cat = CategoryFactory(position=i + 1)
cat.title = fake.word()
cat.save()
sys.stdout.write(" Cat. {}/{} \r".format(i + 1, nb_categories))
sys.stdout.flush()
tps2 = time.time()
cli.stdout.write(u"\nFait en {} sec".format(tps2 - tps1))
def setUp(self):
# Create some forum's category
self.category1 = CategoryFactory(position=1)
self.category2 = CategoryFactory(position=2)
# Create forum
self.forum11 = ForumFactory(category=self.category1, position_in_category=1)
# Only for staff
self.staff1 = StaffProfileFactory()
self.forum12 = ForumFactory(category=self.category2, position_in_category=2)
self.forum12.group.add(Group.objects.filter(name='staff').first())
self.forum12.save()
def test_mark_notifications_as_read(self):
category = CategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=self.user1)
PostFactory(topic=topic, author=self.user1, position=1)
PostFactory(topic=topic, author=self.user2, position=2)
self.assertTrue(
self.client.login(username=self.user1.username,
password='******'))
notifications = Notification.objects.get_unread_notifications_of(
self.user1)
self.assertEqual(1, len(notifications))
self.assertFalse(is_read(topic, self.user1))
result = self.client.post(reverse('mark-notifications-as-read'),
follow=False)
self.assertEqual(result.status_code, 302)
notifications = Notification.objects.get_unread_notifications_of(
self.user1)
self.assertEqual(0, len(notifications))
self.assertTrue(is_read(topic, self.user1))
def test_subscribe_association(self):
"""
To test the "subscription to the association" form.
"""
forum_category = CategoryFactory(position=1)
forum = ForumFactory(category=forum_category, position_in_category=1)
# overrides the settings to avoid 404 if forum does not exist
settings.ZDS_APP['site']['association']['forum_ca_pk'] = forum.pk
# send form
long_str = ''
for i in range(3100):
long_str += 'A'
result = self.client.post(reverse('pages-assoc-subscribe'), {
'full_name': 'Anne Onyme',
'email': '*****@*****.**',
'naissance': '01 janvier 1970',
'adresse': '42 rue du savoir, appartement 42, 75000 Paris, France',
'justification': long_str
},
follow=False)
self.assertEqual(result.status_code, 200)
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=CategoryFactory(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()
def setUp(self):
# prepare a user and 2 Topic (with and without tags)
settings.EMAIL_BACKEND = \
'django.core.mail.backends.locmem.EmailBackend'
self.category1 = CategoryFactory(position=1)
self.forum = ForumFactory(
category=self.category1,
position_in_category=1)
self.forum2 = ForumFactory(
category=self.category1,
position_in_category=2)
self.user = ProfileFactory().user
log = self.client.login(
username=self.user.username,
password='******')
self.assertEqual(log, True)
self.tag = TagFactory()
self.topic1 = TopicFactory(forum=self.forum, author=self.user)
self.topic2 = TopicFactory(forum=self.forum2, author=self.user)
self.topic2.tags.add(self.tag)
self.topic2.save()
self.topicfeed = LastTopicsFeedRSS()
def setUp(self):
self.user1 = ProfileFactory()
self.staff = StaffProfileFactory()
# Create a forum for later test
self.forumcat = CategoryFactory()
self.forum = ForumFactory(category=self.forumcat)
self.forumtopic = TopicFactory(forum=self.forum, author=self.staff.user)
def setUp(self):
# don't build PDF to speed up the tests
settings.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
settings.ZDS_APP['member']['bot_account'] = self.mas.username
bot = Group(name=settings.ZDS_APP['member']['bot_group'])
bot.save()
self.external = UserFactory(
username=settings.ZDS_APP['member']['external_account'],
password='******')
self.beta_forum = ForumFactory(
pk=settings.ZDS_APP['forum']['beta_forum_id'],
category=CategoryFactory(position=1),
position_in_category=1
) # ensure that the forum, for the beta versions, is created
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory()
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.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().user
self.user2 = ProfileFactory().user
self.category1 = CategoryFactory(position=1)
self.forum11 = ForumFactory(category=self.category1, position_in_category=1)
self.forum12 = ForumFactory(category=self.category1, position_in_category=2)
self.assertTrue(self.client.login(username=self.user1.username, password='******'))
def setUp(self):
settings.EMAIL_BACKEND = \
'django.core.mail.backends.locmem.EmailBackend'
self.category1 = CategoryFactory(position=1)
self.category2 = CategoryFactory(position=2)
self.category3 = CategoryFactory(position=3)
self.forum11 = ForumFactory(category=self.category1,
position_in_category=1)
self.forum12 = ForumFactory(category=self.category1,
position_in_category=2)
self.forum13 = ForumFactory(category=self.category1,
position_in_category=3)
self.forum21 = ForumFactory(category=self.category2,
position_in_category=1)
self.forum22 = ForumFactory(category=self.category2,
position_in_category=2)
self.user = ProfileFactory().user
def setUp(self):
# Create some forum's category
self.category1 = CategoryFactory(position=1)
self.category2 = CategoryFactory(position=2)
# Create forum
self.forum11 = ForumFactory(category=self.category1,
position_in_category=1)
# Only for staff
self.staff1 = StaffProfileFactory()
self.forum12 = ForumFactory(category=self.category2,
position_in_category=2)
self.forum12.groups.add(Group.objects.filter(name='staff').first())
self.forum12.save()
# don't build PDF to speed up the tests
settings.ZDS_APP['content']['build_pdf_when_published'] = False
def setUp(self):
self.user1 = ProfileFactory().user
self.user2 = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.assertTrue(self.staff.has_perm('forum.change_topic'))
self.category1 = CategoryFactory(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.group.add(group)
self.forum12.save()
def test_no_duplicate_subscription(self):
"""
Creating two same subscriptions is rejected by the database.
"""
category = CategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=self.user1)
TopicAnswerSubscription.objects.toggle_follow(topic, self.user1, True)
subscription = TopicAnswerSubscription(user=self.user1, content_object=topic)
with self.assertRaises(IntegrityError):
subscription.save()
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 = CategoryFactory(position=1)
self.forum11 = ForumFactory(category=self.category1,
position_in_category=1)
self.staff = StaffProfileFactory().user
def test_update(self):
# create topic and content and toggle request
author = ProfileFactory().user
category = CategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=author)
FeaturedRequested.objects.toogle_request(topic, author)
# ignore
staff = StaffProfileFactory()
login_check = self.client.login(username=staff.user.username,
password='******')
self.assertTrue(login_check)
content_type = ContentType.objects.get_for_model(topic)
q = FeaturedRequested.objects.get(object_id=topic.pk,
content_type__pk=content_type.pk)
self.assertFalse(q.rejected)
response = self.client.post(reverse('featured-resource-request-update',
kwargs={'pk': q.pk}),
{'operation': 'REJECT'},
follow=False)
self.assertEqual(200, response.status_code)
q = FeaturedRequested.objects.get(pk=q.pk)
self.assertTrue(q.rejected)
self.assertFalse(q.rejected_for_good)
response = self.client.post(reverse('featured-resource-request-update',
kwargs={'pk': q.pk}),
{'operation': 'CONSIDER'},
follow=False)
self.assertEqual(200, response.status_code)
q = FeaturedRequested.objects.get(pk=q.pk)
self.assertFalse(q.rejected)
response = self.client.post(reverse('featured-resource-request-update',
kwargs={'pk': q.pk}),
{'operation': 'REJECT_FOR_GOOD'},
follow=False)
self.assertEqual(200, response.status_code)
q = FeaturedRequested.objects.get(pk=q.pk)
self.assertTrue(q.rejected)
self.assertTrue(q.rejected_for_good)
def setUp(self):
# don't build PDF to speed up the tests
settings.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
settings.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=settings.ZDS_APP['forum']['beta_forum_id'],
category=CategoryFactory(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=settings.ZDS_APP["member"]["bot_group"])
bot.save()
self.external = UserFactory(
username=settings.ZDS_APP["member"]["external_account"],
password="******")
def setUp(self):
self.staff = StaffFactory()
self.dummy_author = ProfileFactory()
self.category = CategoryFactory(position=1)
self.forum = ForumFactory(category=self.category, position_in_category=1)
self.topic = TopicFactory(forum=self.forum, author=self.dummy_author.user)
self.post = PostFactory(topic=self.topic, author=self.dummy_author.user, position=1)
self.alerts = []
for i in range(20):
alert = Alert(author=self.dummy_author.user,
comment=self.post,
scope='FORUM',
text=u'pouet-{}'.format(i),
pubdate=(datetime.now() + timedelta(minutes=i)))
alert.save()
self.alerts.append(alert)
def test_mark_all_notifications_as_read_when_toggle_follow(self):
"""
When a user unsubscribes from a content, we mark all notifications for
this content as read.
"""
category = CategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=self.user1)
PostFactory(topic=topic, author=self.user1, position=1)
PostFactory(topic=topic, author=self.user2, position=2)
notifications = Notification.objects.get_unread_notifications_of(self.user1)
self.assertEqual(1, len(notifications))
self.assertIsNotNone(notifications.first())
self.assertEqual(topic.last_message, notifications.first().content_object)
TopicAnswerSubscription.objects.toggle_follow(topic, self.user1)
self.assertEqual(0, len(Notification.objects.get_unread_notifications_of(self.user1)))
def test_success_initial_content_topic(self):
author = ProfileFactory().user
category = CategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=author)
staff = StaffProfileFactory()
login_check = self.client.login(username=staff.user.username,
password='******')
self.assertTrue(login_check)
response = self.client.get(
'{}?content_type=topic&content_id={}'.format(
reverse('featured-resource-create'), topic.id))
initial_dict = response.context['form'].initial
self.assertEqual(initial_dict['title'], topic.title)
self.assertEqual(initial_dict['authors'], str(author))
self.assertEqual(initial_dict['type'], _('Un sujet'))
self.assertEqual(
initial_dict['url'],
'http://testserver{}'.format(topic.get_absolute_url()))
def setUp(self):
# prepare a user and 2 Topic (with and without tags)
settings.EMAIL_BACKEND = \
'django.core.mail.backends.locmem.EmailBackend'
self.category1 = CategoryFactory(position=1)
self.forum = ForumFactory(
category=self.category1,
position_in_category=1)
self.forum2 = ForumFactory(
category=self.category1,
position_in_category=2)
self.forum3 = ForumFactory(
category=self.category1,
position_in_category=3)
self.user = ProfileFactory().user
log = self.client.login(
username=self.user.username,
password='******')
self.assertEqual(log, True)
self.tag = TagFactory()
self.topic1 = TopicFactory(forum=self.forum, author=self.user)
self.topic2 = TopicFactory(forum=self.forum2, author=self.user)
self.topic2.tags.add(self.tag)
self.topic2.save()
# create 2 posts un each forum
PostFactory(topic=self.topic1, author=self.user, position=1)
PostFactory(topic=self.topic1, author=self.user, position=2)
PostFactory(topic=self.topic2, author=self.user, position=1)
PostFactory(topic=self.topic2, author=self.user, position=2)
# and last topic + post alone
self.tag2 = TagFactory()
self.topic3 = TopicFactory(forum=self.forum3, author=self.user)
self.post3 = PostFactory(topic=self.topic3, author=self.user, position=1)
self.topic3.tags.add(self.tag2)
self.topic3.save()
self.postfeed = LastPostsFeedRSS()
def test_toggle(self):
author = ProfileFactory()
login_check = self.client.login(username=author.user.username,
password='******')
self.assertTrue(login_check)
# create topic and toggle request
category = CategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=author.user)
response = self.client.post(reverse('topic-edit') +
'?topic={}'.format(topic.pk),
{'request_featured': 1},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 1)
r = FeaturedRequested.objects.last()
self.assertEqual(r.content_object, topic)
self.assertIn(author.user, r.users_voted.all())
# lock topic: cannot vote anymore
topic.is_locked = True
topic.save()
response = self.client.post(reverse('topic-edit') +
'?topic={}'.format(topic.pk),
{'request_featured': 1},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(403, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 1)
# create tutorial and toggle request
tutorial = PublishedContentFactory(author_list=[author.user])
gallery = GalleryFactory()
image = ImageFactory(gallery=gallery)
tutorial.image = image
tutorial.save()
response = self.client.post(reverse('content:request-featured',
kwargs={'pk': tutorial.pk}),
{'request_featured': 1},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 2)
r = FeaturedRequested.objects.last()
self.assertEqual(r.content_object, tutorial)
self.assertIn(author.user, r.users_voted.all())
# create opinion: cannot toggle request!
opinion = PublishedContentFactory(type='OPINION',
author_list=[author.user])
gallery = GalleryFactory()
image = ImageFactory(gallery=gallery)
opinion.image = image
opinion.save()
response = self.client.post(reverse('content:request-featured',
kwargs={'pk': opinion.pk}),
{'request_featured': 1},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(403, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 2)
# set tutorial as obsolete: cannot toggle
tutorial.is_obsolete = True
tutorial.save()
response = self.client.post(reverse('content:request-featured',
kwargs={'pk': tutorial.pk}),
{'request_featured': 1},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(403, response.status_code)
r = FeaturedRequested.objects.get(pk=r.pk)
self.assertEqual(r.content_object, tutorial)
self.assertIn(author.user, r.users_voted.all())
# reject tutorial proposition
tutorial.is_obsolete = False # can vote again
tutorial.save()
r = FeaturedRequested.objects.get(pk=r.pk)
r.rejected = True
r.save()
# upvote with other user
other = ProfileFactory()
login_check = self.client.login(username=other.user.username,
password='******')
self.assertTrue(login_check)
response = self.client.post(reverse('content:request-featured',
kwargs={'pk': tutorial.pk}),
{'request_featured': 1},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
r = FeaturedRequested.objects.get(pk=r.pk)
self.assertIn(other.user, r.users_voted.all())
self.assertFalse(r.rejected) # not rejected anymore
# reject for good, cannot vote anymore!
r.rejected_for_good = True
r.save()
response = self.client.post(reverse('content:request-featured',
kwargs={'pk': tutorial.pk}),
{'request_featured': 1},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(403, response.status_code)
r = FeaturedRequested.objects.get(pk=r.pk)
self.assertIn(other.user, r.users_voted.all())
def setUp(self):
settings.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=CategoryFactory(position=1),
position_in_category=1
) # ensure that the forum, for the beta versions, is created
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory()
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
# create a tutorial
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()
# fill it with one part, containing one chapter, containing one extract
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)
# then, publish it !
version = self.tuto_draft.current_version
self.published = publish_content(self.tuto,
self.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.tutofeed = LastTutorialsFeedRSS()
def test_migrate_zep12(self):
private_mini_tuto = MiniTutorialFactory(title="Private Mini tuto")
private_mini_tuto.authors.add(self.user_author)
private_mini_tuto.save()
multi_author_tuto = MiniTutorialFactory(title="Multi User Tuto")
multi_author_tuto.authors.add(self.user_author)
multi_author_tuto.authors.add(self.staff)
multi_author_tuto.save()
public_mini_tuto = PublishedMiniTutorial(title="Public Mini Tuto")
public_mini_tuto.authors.add(self.user_author)
public_mini_tuto.save()
OldTutoValidation(
tutorial=public_mini_tuto,
version=public_mini_tuto.sha_public,
date_proposition=datetime.datetime.now(),
comment_authors=u"La vie est belle, le destin s'en écarte.",
comment_validator=u"Personne ne joue avec les mêmes cartes.",
validator=self.staff,
status="ACCEPT",
date_reserve=datetime.datetime.now(),
date_validation=datetime.datetime.now()).save()
staff_note = NoteFactory(tutorial=public_mini_tuto,
position=1,
author=self.staff)
liked_note = NoteFactory(tutorial=public_mini_tuto,
position=2,
author=self.user_author)
t_read = TutorialRead()
t_read.tutorial = public_mini_tuto
t_read.user = self.staff
t_read.note = staff_note
t_read.save()
like = CommentLike()
like.comments = liked_note
like.user = self.staff
like.save()
big_tuto = BigTutorialFactory(title="Big tuto")
big_tuto.authors.add(self.user_author)
big_tuto.save()
public_big_tuto = PublishedBigTutorial(light=False,
title="Public Big Tuto")
public_big_tuto.authors.add(self.user_author)
public_big_tuto.save()
private_article = ArticleFactory(title="Private Article")
private_article.authors.add(self.user_author)
private_article.save()
multi_author_article = ArticleFactory(title="Multi Author Article")
multi_author_article.authors.add(self.user_author)
multi_author_article.authors.add(self.staff)
multi_author_article.save()
public_article = PublishedArticleFactory(title="Public Article")
public_article.authors.add(self.user_author)
public_article.save()
OldArticleValidation(
article=public_article,
version=public_article.sha_public,
date_proposition=datetime.datetime.now(),
comment_authors=u"Pourquoi fortune et infortune?",
comment_validator=u"Pourquoi suis-je né les poches vides?",
validator=self.staff,
status="ACCEPT",
date_reserve=datetime.datetime.now(),
date_validation=datetime.datetime.now()).save()
staff_note = ReactionFactory(article=public_article,
position=1,
author=self.staff)
liked_reaction = ReactionFactory(article=public_article,
position=2,
author=self.user_author)
a_read = ArticleRead()
a_read.article = public_article
a_read.user = self.staff
a_read.reaction = staff_note
a_read.save()
like = CommentLike()
like.comments = liked_reaction
like.user = self.staff
like.save()
category1 = CategoryFactory(position=1)
forum11 = ForumFactory(category=category1, position_in_category=1)
beta_tuto = BetaMiniTutorialFactory(title=u"Beta Tuto",
forum=forum11,
author=self.user_author)
beta_tuto.authors.add(self.user_author)
beta_tuto.save()
call_command('migrate_to_zep12')
# 1 tuto in setup, 4 mini tutos, 1 big tuto, 3 articles
self.assertEqual(
PublishableContent.objects.filter(
authors__pk__in=[self.user_author.pk]).count(), 10)
# if we had n published content we must have 2 * n PublishedContent entities to handle redirections.
self.assertEqual(
PublishedContent.objects.filter(
content__authors__pk__in=[self.user_author.pk]).count(), 2 * 3)
self.assertEqual(
ContentReaction.objects.filter(author__pk=self.staff.pk).count(),
2)
migrated_pulished_article = PublishableContent.objects.filter(
authors__in=[self.user_author],
title=public_article.title,
type="ARTICLE").first()
self.assertIsNotNone(migrated_pulished_article)
self.assertIsNotNone(migrated_pulished_article.last_note)
self.assertEqual(
2,
ContentReaction.objects.filter(
related_content=migrated_pulished_article).count())
self.assertEqual(
1,
ContentRead.objects.filter(
content=migrated_pulished_article).count())
self.assertTrue(
migrated_pulished_article.is_public(
migrated_pulished_article.sha_public))
self.assertTrue(
migrated_pulished_article.load_version(
migrated_pulished_article.sha_public).has_extracts())
self.assertEqual(
len(
migrated_pulished_article.load_version(
migrated_pulished_article.sha_public).children), 2)
migrated_pulished_tuto = PublishableContent.objects.filter(
authors__in=[self.user_author],
title=public_mini_tuto.title,
type="TUTORIAL").first()
self.assertIsNotNone(migrated_pulished_tuto)
self.assertIsNotNone(migrated_pulished_tuto.last_note)
self.assertEqual(
2,
ContentReaction.objects.filter(
related_content=migrated_pulished_tuto).count())
self.assertEqual(
1,
ContentRead.objects.filter(content=migrated_pulished_tuto).count())
self.assertTrue(
migrated_pulished_tuto.is_public(
migrated_pulished_tuto.sha_public))
beta_content = PublishableContent.objects.filter(
title=beta_tuto.title).first()
self.assertIsNotNone(beta_content)
self.assertEqual(beta_content.sha_beta, beta_tuto.sha_beta)
self.assertEqual(
Topic.objects.filter(key=beta_tuto.pk).first().pk,
beta_content.beta_topic.pk)
multi_author_content = PublishableContent.objects.filter(type="TUTORIAL", title=multi_author_tuto.title)\
.first()
self.assertIsNotNone(multi_author_content)
self.assertEqual(multi_author_content.authors.count(),
multi_author_tuto.authors.count())
multi_author_content = PublishableContent.objects.filter(type="ARTICLE", title=multi_author_article.title)\
.first()
self.assertIsNotNone(multi_author_content)
self.assertEqual(multi_author_content.authors.count(),
multi_author_article.authors.count())
old_tutorial_module_prefix = "oldtutoriels"
old_article_module_prefix = "oldarticles"
new_tutorial_module_prefix = "tutoriels"
new_article_module_prefix = "articles"
public_article_url = public_article.get_absolute_url_online()\
.replace(old_article_module_prefix, new_article_module_prefix)
public_tutorial_url = public_mini_tuto.get_absolute_url_online()\
.replace(old_tutorial_module_prefix, new_tutorial_module_prefix)
self.assertEqual(301, self.client.get(public_article_url).status_code)
self.assertEqual(301, self.client.get(public_tutorial_url).status_code)
public_chapter = Chapter.objects.filter(
part__tutorial__pk=public_big_tuto.pk).first()
self.assertIsNotNone(public_chapter)
public_chapter_url = public_chapter.get_absolute_url_online()
public_chapter_url = public_chapter_url.replace(
old_tutorial_module_prefix, new_tutorial_module_prefix)
self.assertEqual(301, self.client.get(public_chapter_url).status_code)
self.assertEqual(
200,
self.client.get(public_chapter_url, follow=True).status_code)
self.assertEqual(
200,
self.client.get(public_article_url, follow=True).status_code)
self.assertEqual(
200,
self.client.get(public_tutorial_url, follow=True).status_code)
tuto_validation = Validation.objects.filter(
content__pk=migrated_pulished_tuto.pk).first()
self.assertIsNotNone(tuto_validation)
self.assertEqual(tuto_validation.status, "ACCEPT")
self.assertEqual(tuto_validation.validator.pk, self.staff.pk)
article_validation = Validation.objects.filter(
content__pk=migrated_pulished_article.pk).first()
self.assertIsNotNone(article_validation)
self.assertEqual(article_validation.status, "ACCEPT")
self.assertEqual(article_validation.validator.pk, self.staff.pk)
def test_promote_interface(self):
"""
Test promotion interface.
"""
# create users (one regular, one staff and one superuser)
tester = ProfileFactory()
staff = StaffProfileFactory()
tester.user.is_active = False
tester.user.save()
staff.user.is_superuser = True
staff.user.save()
# create groups
group = Group.objects.create(name="DummyGroup_1")
groupbis = Group.objects.create(name="DummyGroup_2")
# create Forums, Posts and subscribe member to them.
category1 = CategoryFactory(position=1)
forum1 = ForumFactory(category=category1, position_in_category=1)
forum1.group.add(group)
forum1.save()
forum2 = ForumFactory(category=category1, position_in_category=2)
forum2.group.add(groupbis)
forum2.save()
forum3 = ForumFactory(category=category1, position_in_category=3)
topic1 = TopicFactory(forum=forum1, author=staff.user)
topic2 = TopicFactory(forum=forum2, author=staff.user)
topic3 = TopicFactory(forum=forum3, author=staff.user)
# LET THE TEST BEGIN !
# tester shouldn't be able to connect
login_check = self.client.login(username=tester.user.username,
password='******')
self.assertEqual(login_check, False)
# connect as staff (superuser)
login_check = self.client.login(username=staff.user.username,
password='******')
self.assertEqual(login_check, True)
# check that we can go through the page
result = self.client.get(reverse('member-settings-promote',
kwargs={'user_pk': tester.user.id}),
follow=False)
self.assertEqual(result.status_code, 200)
# give user rights and groups thanks to staff (but account still not activated)
result = self.client.post(reverse('member-settings-promote',
kwargs={'user_pk': tester.user.id}),
{
'groups': [group.id, groupbis.id],
'superuser': "******",
},
follow=False)
self.assertEqual(result.status_code, 302)
tester = Profile.objects.get(id=tester.id) # refresh
self.assertEqual(len(tester.user.groups.all()), 2)
self.assertFalse(tester.user.is_active)
self.assertTrue(tester.user.is_superuser)
# Now our tester is going to follow one post in every forum (3)
TopicAnswerSubscription.objects.toggle_follow(topic1, tester.user)
TopicAnswerSubscription.objects.toggle_follow(topic2, tester.user)
TopicAnswerSubscription.objects.toggle_follow(topic3, tester.user)
self.assertEqual(
len(
TopicAnswerSubscription.objects.get_objects_followed_by(
tester.user)), 3)
# retract all right, keep one group only and activate account
result = self.client.post(reverse('member-settings-promote',
kwargs={'user_pk': tester.user.id}),
{
'groups': [group.id],
'activation': "on"
},
follow=False)
self.assertEqual(result.status_code, 302)
tester = Profile.objects.get(id=tester.id) # refresh
self.assertEqual(len(tester.user.groups.all()), 1)
self.assertTrue(tester.user.is_active)
self.assertFalse(tester.user.is_superuser)
self.assertEqual(
len(
TopicAnswerSubscription.objects.get_objects_followed_by(
tester.user)), 2)
# no groups specified
result = self.client.post(reverse('member-settings-promote',
kwargs={'user_pk': tester.user.id}),
{'activation': "on"},
follow=False)
self.assertEqual(result.status_code, 302)
tester = Profile.objects.get(id=tester.id) # refresh
self.assertEqual(
len(
TopicAnswerSubscription.objects.get_objects_followed_by(
tester.user)), 1)
# check that staff can't take away it's own super user rights
result = self.client.post(reverse('member-settings-promote',
kwargs={'user_pk': staff.user.id}),
{'activation': "on"},
follow=False)
self.assertEqual(result.status_code, 302)
staff = Profile.objects.get(id=staff.id) # refresh
self.assertTrue(staff.user.is_superuser) # still superuser !
# Finally, check that user can connect and can not access the interface
login_check = self.client.login(username=tester.user.username,
password='******')
self.assertEqual(login_check, True)
result = self.client.post(reverse('member-settings-promote',
kwargs={'user_pk': staff.user.id}),
{'activation': "on"},
follow=False)
self.assertEqual(result.status_code, 403) # forbidden !
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 register.
user = ProfileFactory()
login_check = self.client.login(username=user.user.username,
password='******')
self.assertEqual(login_check, True)
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.login(username=self.staff.username, password="******")
# 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=CategoryFactory())
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)
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)
# login and unregister:
login_check = self.client.login(username=user.user.username,
password='******')
self.assertEqual(login_check, True)
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(
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.assertEquals(alone_gallery.get_linked_users().count(), 1)
self.assertEquals(shared_gallery.get_linked_users().count(), 1)
self.assertEquals(
UserGallery.objects.filter(user=user.user).count(), 0)
self.assertEquals(
CommentVote.objects.filter(user=user.user, positive=True).count(),
0)
self.assertEquals(
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)
def test_filters(self):
# create topic and content and toggle request
author = ProfileFactory().user
category = CategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=author)
FeaturedRequested.objects.toogle_request(topic, author)
tutorial = PublishedContentFactory(author_list=[author])
gallery = GalleryFactory()
image = ImageFactory(gallery=gallery)
tutorial.image = image
tutorial.save()
FeaturedRequested.objects.toogle_request(tutorial, author)
# without filter
staff = StaffProfileFactory()
login_check = self.client.login(username=staff.user.username,
password='******')
self.assertTrue(login_check)
response = self.client.get(reverse('featured-resource-requests'))
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context['featured_request_list']), 2)
self.assertTrue(
any(r.content_object == topic
for r in response.context['featured_request_list']))
self.assertTrue(
any(r.content_object == tutorial
for r in response.context['featured_request_list']))
# filter topic
response = self.client.get(
reverse('featured-resource-requests') + '?type=topic')
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context['featured_request_list']), 1)
self.assertTrue(
any(r.content_object == topic
for r in response.context['featured_request_list']))
self.assertFalse(
any(r.content_object == tutorial
for r in response.context['featured_request_list']))
# filter tuto
response = self.client.get(
reverse('featured-resource-requests') + '?type=content')
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context['featured_request_list']), 1)
self.assertFalse(
any(r.content_object == topic
for r in response.context['featured_request_list']))
self.assertTrue(
any(r.content_object == tutorial
for r in response.context['featured_request_list']))
# reject topic
content_type = ContentType.objects.get_for_model(topic)
q = FeaturedRequested.objects.get(object_id=topic.pk,
content_type__pk=content_type.pk)
q.rejected = True
q.save()
response = self.client.get(
reverse('featured-resource-requests') + '?type=topic')
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context['featured_request_list']), 0)
# filter ignored
response = self.client.get(
reverse('featured-resource-requests') + '?type=ignored')
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context['featured_request_list']), 1)
self.assertTrue(
any(r.content_object == topic
for r in response.context['featured_request_list']))
# put back vote count to 0 for tutorial
FeaturedRequested.objects.toogle_request(tutorial, author)
response = self.client.get(
reverse('featured-resource-requests') + '?type=content')
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context['featured_request_list']),
0) # does not appear with no votes
# upvote topic
other = ProfileFactory().user
FeaturedRequested.objects.toogle_request(topic, other)
response = self.client.get(
reverse('featured-resource-requests') + '?type=topic')
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context['featured_request_list']),
1) # it is back!
