def test_image_with_non_ascii_chars(self):
"""seen on #4144"""
article = PublishableContentFactory(type='article', author_list=[self.user_author])
image_string = '.]' \
'(/media/galleries/4410/c1016bf1-a1de-48a1-9ef1-144308e8725d.jpg)'
article.sha_draft = article.load_version().repo_update(article.title, image_string, '', update_slug=False)
article.save(force_slug_update=False)
publish_content(article, article.load_version())
self.assertTrue(PublishedContent.objects.filter(content_id=article.pk).exists())
def test_only_one_notif_on_major_update(self):
NewPublicationSubscription.objects.get_or_create_active(self.user1, self.user2)
content = PublishedContentFactory(author_list=[self.user2])
notify_update(content, False, True)
versioned = content.load_version()
content.sha_draft = versioned.repo_update(introduction='new intro', conclusion='new conclusion',
title=versioned.title)
content.save(force_slug_update=False)
publish_content(content, content.load_version(), True)
notify_update(content, True, True)
notifs = get_header_notifications(self.user1)['general_notifications']['list']
self.assertEqual(1, len(notifs), str(notifs))
def create_multiple_tags(self, number_of_tags=REST_PAGE_SIZE):
tags = []
for tag in range(0, number_of_tags):
tags.append('number' + str(tag))
# Prepare content containing all the tags
content = PublishableContentFactory(type='TUTORIAL')
content.add_tags(tags)
content.save()
content_draft = content.load_version()
# then, publish it !
publish_content(content, content_draft)
def form_valid(self, form):
# get database representation
db_object = self.object
is_update = bool(db_object.sha_public)
if self.object.is_permanently_unpublished():
raise PermissionDenied
versioned = self.versioned_object
self.success_url = versioned.get_absolute_url()
try:
published = publish_content(db_object, versioned, is_major_update=False)
except FailureDuringPublication as e:
messages.error(self.request, e.message)
else:
# save in database
db_object.source = form.cleaned_data['source']
db_object.sha_validation = None
db_object.public_version = published
db_object.save()
# if only ignore, we remove it from history
PickListOperation.objects.filter(content=db_object,
operation__in=['NO_PICK', 'PICK']).update(is_effective=False)
notify_update(db_object, is_update, form.cleaned_data.get('is_major', False))
messages.success(self.request, _('Le contenu a bien été publié.'))
self.success_url = published.get_absolute_url_online()
return super(PublishOpinion, self).form_valid(form)
def test_char_count_after_publication(self):
"""Test the ``get_char_count()`` function.
Special care should be taken with this function, since:
- The username of the author is, by default "Firmxxx" where "xxx" depends on the tests before ;
- The titles (!) also contains a number that also depends on the number of tests before ;
- The date is ``datetime.now()`` and contains the months, which is never a fixed number of letters.
"""
author = ProfileFactory().user
author.username = '******'
author.save()
len_date_now = len(date(datetime.now(), 'd F Y'))
article = PublishedContentFactory(type='ARTICLE', author_list=[author], title='Un titre')
published = PublishedContent.objects.filter(content=article).first()
self.assertEqual(published.get_char_count(), 160 + len_date_now)
tuto = PublishableContentFactory(type='TUTORIAL', author_list=[author], title='Un titre')
# add a chapter, so it becomes a middle tutorial
tuto_draft = tuto.load_version()
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto, title='Un chapitre')
ExtractFactory(container=chapter1, db_object=tuto, title='Un extrait')
published = publish_content(tuto, tuto_draft, is_major_update=True)
tuto.sha_public = tuto_draft.current_version
tuto.sha_draft = tuto_draft.current_version
tuto.public_version = published
tuto.save()
published = PublishedContent.objects.filter(content=tuto).first()
self.assertEqual(published.get_char_count(), 335 + len_date_now)
def setUp(self):
# don't build PDF to speed up the tests
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.assertTrue(self.client.login(username=self.user1.username, password='******'))
def form_valid(self, form):
user = self.request.user
validation = Validation.objects.filter(pk=self.kwargs['pk']).last()
if not validation:
raise PermissionDenied
if validation.validator != user:
raise PermissionDenied
if validation.status != 'PENDING_V':
raise PermissionDenied
# get database representation and validated version
db_object = validation.content
versioned = db_object.load_version(sha=validation.version)
self.success_url = versioned.get_absolute_url(version=validation.version)
is_update = db_object.sha_public
try:
published = publish_content(db_object, versioned, is_major_update=form.cleaned_data['is_major'])
except FailureDuringPublication as e:
messages.error(self.request, e.message)
else:
self.save_validation_state(db_object, form, is_update, published, validation, versioned)
notify_update(db_object, is_update, form.cleaned_data['is_major'])
messages.success(self.request, _('Le contenu a bien été validé.'))
self.success_url = published.get_absolute_url_online()
return super(AcceptValidation, self).form_valid(form)
def publish_opinion(content, action_flag, versioned):
if action_flag >= 1:
content.sha_public = content.sha_draft
if action_flag == 1:
content.sha_picked = content.sha_draft
published = publish_content(content, versioned)
content.public_version = published
content.save()
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.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):
# 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 test_publish_content_article(self):
"""test and ensure the behavior of ``publish_content()`` and ``unpublish_content()``"""
# 1. Article:
article = PublishableContentFactory(type='ARTICLE')
article.authors.add(self.user_author)
UserGalleryFactory(gallery=article.gallery, user=self.user_author, mode='W')
article.licence = self.licence
article.save()
# populate the article
article_draft = article.load_version()
ExtractFactory(container=article_draft, db_object=article)
ExtractFactory(container=article_draft, db_object=article)
self.assertEqual(len(article_draft.children), 2)
# publish !
article = PublishableContent.objects.get(pk=article.pk)
published = publish_content(article, article_draft)
self.assertEqual(published.content, article)
self.assertEqual(published.content_pk, article.pk)
self.assertEqual(published.content_type, article.type)
self.assertEqual(published.content_public_slug, article_draft.slug)
self.assertEqual(published.sha_public, article.sha_draft)
public = article.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # it's a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test object created in database
self.assertEqual(PublishedContent.objects.filter(content=article).count(), 1)
published = PublishedContent.objects.filter(content=article).last()
self.assertEqual(published.content_pk, article.pk)
self.assertEqual(published.content_public_slug, article_draft.slug)
self.assertEqual(published.content_type, article.type)
self.assertEqual(published.sha_public, public.current_version)
# test creation of files:
self.assertTrue(os.path.isdir(published.get_prod_path()))
self.assertTrue(os.path.isfile(os.path.join(published.get_prod_path(), 'manifest.json')))
prod_path = public.get_prod_path()
self.assertTrue(prod_path.endswith('.html'), prod_path)
self.assertTrue(os.path.isfile(prod_path), prod_path) # normally, an HTML file should exists
self.assertIsNone(public.introduction) # since all is in the HTML file, introduction does not exists anymore
self.assertIsNone(public.conclusion)
article.public_version = published
article.save()
# depublish it !
unpublish_content(article)
self.assertEqual(PublishedContent.objects.filter(content=article).count(), 0) # published object disappear
self.assertFalse(os.path.exists(public.get_prod_path())) # article was removed
def test_publish_content_article(self):
"""test and ensure the behavior of ``publish_content()`` and ``unpublish_content()``"""
# 1. Article:
article = PublishableContentFactory(type="ARTICLE")
article.authors.add(self.user_author)
UserGalleryFactory(gallery=article.gallery, user=self.user_author, mode="W")
article.licence = self.licence
article.save()
# populate the article
article_draft = article.load_version()
ExtractFactory(container=article_draft, db_object=article)
ExtractFactory(container=article_draft, db_object=article)
self.assertEqual(len(article_draft.children), 2)
# publish !
article = PublishableContent.objects.get(pk=article.pk)
published = publish_content(article, article_draft)
self.assertEqual(published.content, article)
self.assertEqual(published.content_pk, article.pk)
self.assertEqual(published.content_type, article.type)
self.assertEqual(published.content_public_slug, article_draft.slug)
self.assertEqual(published.sha_public, article.sha_draft)
public = article.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # it's a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test object created in database
self.assertEqual(PublishedContent.objects.filter(content=article).count(), 1)
published = PublishedContent.objects.filter(content=article).last()
self.assertEqual(published.content_pk, article.pk)
self.assertEqual(published.content_public_slug, article_draft.slug)
self.assertEqual(published.content_type, article.type)
self.assertEqual(published.sha_public, public.current_version)
# test creation of files:
self.assertTrue(os.path.isdir(published.get_prod_path()))
self.assertTrue(os.path.isfile(os.path.join(published.get_prod_path(), "manifest.json")))
prod_path = public.get_prod_path()
self.assertTrue(prod_path.endswith(".html"), prod_path)
self.assertTrue(os.path.isfile(prod_path), prod_path) # normally, an HTML file should exists
self.assertIsNone(public.introduction) # since all is in the HTML file, introduction does not exists anymore
self.assertIsNone(public.conclusion)
article.public_version = published
article.save()
# depublish it !
unpublish_content(article)
self.assertEqual(PublishedContent.objects.filter(content=article).count(), 0) # published object disappear
self.assertFalse(os.path.exists(public.get_prod_path())) # article was removed
def test_publish_content_big_tuto(self):
# 4. Big tutorial:
bigtuto = PublishableContentFactory(type='TUTORIAL')
bigtuto.authors.add(self.user_author)
UserGalleryFactory(gallery=bigtuto.gallery, user=self.user_author, mode='W')
bigtuto.licence = self.licence
bigtuto.save()
# populate with 2 part (1 chapter with 1 extract each)
bigtuto_draft = bigtuto.load_version()
part1 = ContainerFactory(parent=bigtuto_draft, db_objet=bigtuto)
chapter1 = ContainerFactory(parent=part1, db_objet=bigtuto)
ExtractFactory(container=chapter1, db_object=bigtuto)
part2 = ContainerFactory(parent=bigtuto_draft, db_objet=bigtuto)
chapter2 = ContainerFactory(parent=part2, db_objet=bigtuto)
ExtractFactory(container=chapter2, db_object=bigtuto)
# publish it
bigtuto = PublishableContent.objects.get(pk=bigtuto.pk)
published = publish_content(bigtuto, bigtuto_draft)
self.assertEqual(published.content, bigtuto)
self.assertEqual(published.content_pk, bigtuto.pk)
self.assertEqual(published.content_type, bigtuto.type)
self.assertEqual(published.content_public_slug, bigtuto_draft.slug)
self.assertEqual(published.sha_public, bigtuto.sha_draft)
public = bigtuto.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # it's a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test creation of files:
self.assertTrue(os.path.isdir(published.get_prod_path()))
self.assertTrue(os.path.isfile(os.path.join(published.get_prod_path(), 'manifest.json')))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.introduction)))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.conclusion)))
self.assertEqual(len(public.children), 2)
for part in public.children:
self.assertTrue(os.path.isdir(part.get_prod_path())) # a directory for each part
# ... and an HTML file for introduction and conclusion
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), part.introduction)))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), part.conclusion)))
self.assertEqual(len(part.children), 1)
for chapter in part.children:
# the HTML file is located in the good directory:
self.assertEqual(part.get_prod_path(), os.path.dirname(chapter.get_prod_path()))
self.assertTrue(os.path.isfile(chapter.get_prod_path())) # an HTML file for each chapter
self.assertIsNone(chapter.introduction)
self.assertIsNone(chapter.conclusion)
def test_publish_content_big_tuto(self):
# 4. Big tutorial:
bigtuto = PublishableContentFactory(type="TUTORIAL")
bigtuto.authors.add(self.user_author)
UserGalleryFactory(gallery=bigtuto.gallery, user=self.user_author, mode="W")
bigtuto.licence = self.licence
bigtuto.save()
# populate with 2 part (1 chapter with 1 extract each)
bigtuto_draft = bigtuto.load_version()
part1 = ContainerFactory(parent=bigtuto_draft, db_object=bigtuto)
chapter1 = ContainerFactory(parent=part1, db_object=bigtuto)
ExtractFactory(container=chapter1, db_object=bigtuto)
part2 = ContainerFactory(parent=bigtuto_draft, db_object=bigtuto)
chapter2 = ContainerFactory(parent=part2, db_object=bigtuto)
ExtractFactory(container=chapter2, db_object=bigtuto)
# publish it
bigtuto = PublishableContent.objects.get(pk=bigtuto.pk)
published = publish_content(bigtuto, bigtuto_draft)
self.assertEqual(published.content, bigtuto)
self.assertEqual(published.content_pk, bigtuto.pk)
self.assertEqual(published.content_type, bigtuto.type)
self.assertEqual(published.content_public_slug, bigtuto_draft.slug)
self.assertEqual(published.sha_public, bigtuto.sha_draft)
public = bigtuto.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # it's a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test creation of files:
self.assertTrue(os.path.isdir(published.get_prod_path()))
self.assertTrue(os.path.isfile(os.path.join(published.get_prod_path(), "manifest.json")))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.introduction)))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.conclusion)))
self.assertEqual(len(public.children), 2)
for part in public.children:
self.assertTrue(os.path.isdir(part.get_prod_path())) # a directory for each part
# ... and an HTML file for introduction and conclusion
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), part.introduction)))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), part.conclusion)))
self.assertEqual(len(part.children), 1)
for chapter in part.children:
# the HTML file is located in the good directory:
self.assertEqual(part.get_prod_path(), os.path.dirname(chapter.get_prod_path()))
self.assertTrue(os.path.isfile(chapter.get_prod_path())) # an HTML file for each chapter
self.assertIsNone(chapter.introduction)
self.assertIsNone(chapter.conclusion)
def test_publish_content_medium_tuto(self):
# 3. Medium-size tutorial
midsize_tuto = PublishableContentFactory(type='TUTORIAL')
midsize_tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=midsize_tuto.gallery,
user=self.user_author,
mode='W')
midsize_tuto.licence = self.licence
midsize_tuto.save()
# populate with 2 chapters (1 extract each)
midsize_tuto_draft = midsize_tuto.load_version()
chapter1 = ContainerFactory(parent=midsize_tuto_draft,
db_objet=midsize_tuto)
ExtractFactory(container=chapter1, db_object=midsize_tuto)
chapter2 = ContainerFactory(parent=midsize_tuto_draft,
db_objet=midsize_tuto)
ExtractFactory(container=chapter2, db_object=midsize_tuto)
# publish it
midsize_tuto = PublishableContent.objects.get(pk=midsize_tuto.pk)
published = publish_content(midsize_tuto, midsize_tuto_draft)
self.assertEqual(published.content, midsize_tuto)
self.assertEqual(published.content_pk, midsize_tuto.pk)
self.assertEqual(published.content_type, midsize_tuto.type)
self.assertEqual(published.content_public_slug,
midsize_tuto_draft.slug)
self.assertEqual(published.sha_public, midsize_tuto.sha_draft)
public = midsize_tuto.load_version(sha=published.sha_public,
public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # it's a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test creation of files:
self.assertTrue(Path(published.get_prod_path()).is_dir())
self.assertTrue(
Path(published.get_prod_path(), 'manifest.json').is_file())
self.assertTrue(
Path(public.get_prod_path(), public.introduction).is_file())
self.assertTrue(
Path(public.get_prod_path(), public.conclusion).is_file())
self.assertEqual(len(public.children), 2)
for child in public.children:
self.assertTrue(os.path.isfile(
child.get_prod_path())) # an HTML file for each chapter
self.assertIsNone(child.introduction)
self.assertIsNone(child.conclusion)
def _prepare(cls, create, **kwargs):
"""create a new PublishableContent and then publish it.
"""
content = super(PublishedContentFactory, cls)._prepare(create, **kwargs)
published = publish_content(content, content.load_version(), True)
content.sha_public = content.sha_draft
content.public_version = published
content.save()
return content
def get_small_opinion(self):
"""
Returns a published opinion without extract.
"""
opinion = PublishableContentFactory(type="OPINION")
opinion.authors.add(self.user_author)
UserGalleryFactory(gallery=opinion.gallery, user=self.user_author, mode="W")
opinion.licence = LicenceFactory()
opinion.save()
opinion_draft = opinion.load_version()
return publish_content(opinion, opinion_draft)
def _create_and_publish_type_in_subcategory(self, content_type,
subcategory):
tuto_1 = PublishableContentFactory(type=content_type,
author_list=[self.user_author])
tuto_1.subcategory.add(subcategory)
tuto_1.save()
tuto_1_draft = tuto_1.load_version()
tuto_1.public_version = publish_content(tuto_1,
tuto_1_draft,
is_major_update=True)
tuto_1.save()
def form_valid(self, form):
user = self.request.user
validation = Validation.objects.filter(pk=self.kwargs["pk"]).last()
if not validation:
raise PermissionDenied
if validation.validator != user:
raise PermissionDenied
if validation.status != "PENDING_V":
raise PermissionDenied
# get database representation and validated version
db_object = validation.content
versioned = db_object.load_version(sha=validation.version)
self.success_url = versioned.get_absolute_url(
version=validation.version)
is_update = db_object.sha_public
try:
published = publish_content(
db_object,
versioned,
is_major_update=form.cleaned_data["is_major"])
except FailureDuringPublication as e:
messages.error(self.request, e.message)
else:
save_validation_state(
db_object,
is_update,
published,
validation,
versioned,
source=db_object.source,
is_major=form.cleaned_data["is_major"],
user=self.request.user,
request=self.request,
comment=form.cleaned_data["text"],
)
notify_update(db_object, is_update, form.cleaned_data["is_major"])
messages.success(self.request, _("Le contenu a bien été validé."))
signals.validation_management.send(
sender=self.__class__,
content=validation.content,
performer=self.request.user,
version=validation.version,
action="accept",
)
self.success_url = published.get_absolute_url_online()
return super().form_valid(form)
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=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_publication_and_attributes_consistency(self):
pubdate = datetime.now() - timedelta(days=1)
article = PublishedContentFactory(type="ARTICLE",
author_list=[self.user_author])
public_version = article.public_version
public_version.publication_date = pubdate
public_version.save()
# everything must come from database to have good datetime comparison
article = PublishableContent.objects.get(pk=article.pk)
article.public_version.load_public_version()
old_date = article.public_version.publication_date
old_title = article.public_version.title()
old_description = article.public_version.description()
article.licence = LicenceFactory()
article.save()
self.assertEqual(
self.client.login(username=self.user_author.username,
password="******"), True)
self.client.post(
reverse("content:edit", args=[article.pk, article.slug]),
{
"title": old_title + "bla",
"description": old_description + "bla",
"type": "ARTICLE",
"licence": article.licence.pk,
"subcategory": SubCategoryFactory().pk,
"last_hash": article.sha_draft,
},
)
article = PublishableContent.objects.prefetch_related(
"public_version").get(pk=article.pk)
article.public_version.load_public_version()
self.assertEqual(old_title, article.public_version.title())
self.assertEqual(old_description, article.public_version.description())
self.assertEqual(old_date, article.public_version.publication_date)
publish_content(article, article.load_version(), False)
article = PublishableContent.objects.get(pk=article.pk)
article.public_version.load_public_version()
self.assertEqual(old_date, article.public_version.publication_date)
self.assertNotEqual(old_date, article.public_version.update_date)
def test_publication_and_attributes_consistency(self):
pubdate = datetime.now() - timedelta(days=1)
article = PublishedContentFactory(type='ARTICLE',
author_list=[self.user_author])
public_version = article.public_version
public_version.publication_date = pubdate
public_version.save()
# everything must come from database to have good datetime comparison
article = PublishableContent.objects.get(pk=article.pk)
article.public_version.load_public_version()
old_date = article.public_version.publication_date
old_title = article.public_version.title()
old_description = article.public_version.description()
article.licence = LicenceFactory()
article.save()
self.assertEqual(
self.client.login(username=self.user_author.username,
password='******'), True)
self.client.post(
reverse('content:edit', args=[article.pk, article.slug]), {
'title': old_title + 'bla',
'description': old_description + 'bla',
'type': 'ARTICLE',
'licence': article.licence.pk,
'subcategory': SubCategoryFactory().pk,
'last_hash': article.sha_draft
})
article = PublishableContent.objects.prefetch_related(
'public_version').get(pk=article.pk)
article.public_version.load_public_version()
self.assertEqual(old_title, article.public_version.title())
self.assertEqual(old_description, article.public_version.description())
self.assertEqual(old_date, article.public_version.publication_date)
publish_content(article, article.load_version(), False)
article = PublishableContent.objects.get(pk=article.pk)
article.public_version.load_public_version()
self.assertEqual(old_date, article.public_version.publication_date)
self.assertNotEqual(old_date, article.public_version.update_date)
def test_publication_and_attributes_consistency(self):
pubdate = datetime.now() - timedelta(days=1)
article = PublishedContentFactory(type='ARTICLE', author_list=[self.user_author])
public_version = article.public_version
public_version.publication_date = pubdate
public_version.save()
# everything must come from database to have good datetime comparison
article = PublishableContent.objects.get(pk=article.pk)
article.public_version.load_public_version()
old_date = article.public_version.publication_date
old_title = article.public_version.title()
old_description = article.public_version.description()
article.licence = LicenceFactory()
article.save()
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
self.client.post(reverse('content:edit', args=[article.pk, article.slug]), {
'title': old_title + 'bla',
'description': old_description + 'bla',
'type': 'ARTICLE',
'licence': article.licence.pk,
'subcategory': SubCategoryFactory().pk,
'last_hash': article.sha_draft
})
article = PublishableContent.objects.prefetch_related('public_version').get(pk=article.pk)
article.public_version.load_public_version()
self.assertEqual(old_title, article.public_version.title())
self.assertEqual(old_description, article.public_version.description())
self.assertEqual(old_date, article.public_version.publication_date)
publish_content(article, article.load_version(), False)
article = PublishableContent.objects.get(pk=article.pk)
article.public_version.load_public_version()
self.assertEqual(old_date, article.public_version.publication_date)
self.assertNotEqual(old_date, article.public_version.update_date)
def handle(self, *args, content: PublishableContent, is_major=False, **options):
content.current_validation = Validation.objects.filter(content=content, status='PENDING_V').first()
versioned = content.load_version(sha=content.current_validation.version)
is_update = content.sha_public
try:
published = publish_content(content, versioned, is_major_update=is_major)
except FailureDuringPublication as e:
self.stdout.write('Publication failed')
logging.getLogger(__name__).exception('Failure during publication', exc_info=e)
else:
save_validation_state(content, is_update, published, content.current_validation, versioned,
options.get('source', ''), is_major, user=content.current_validation.validator,
comment=_("Géré depuis la commande d'administration"))
notify_update(content, is_update, is_major)
self.stdout.write(_('La contenu a été validé'))
def _generate(cls, create, attrs):
# This parameter is only used inside _generate() and won't be saved in the database,
# which is why we use attrs.pop() (it is removed from attrs).
is_major_update = attrs.pop("is_major_update", True)
# Creates the PublishableContent (see PublishableContentFactory._generate() for more info)
content = super()._generate(create, attrs)
published = publish_content(content, content.load_version(), is_major_update)
content.sha_public = content.sha_draft
content.public_version = published
content.save()
return content
def validate_edited_content(content, fake, nb_staffs, staffs, to_do, versioned):
valid = CValidation(content=content, version=content.sha_draft, date_proposition=datetime.now(), status="PENDING")
valid.comment_validator = fake.text(max_nb_chars=200)
content.sha_validation = content.sha_draft
if to_do > 1: # reserve validation
valid.date_reserve = datetime.now()
valid.validator = staffs[random.randint(0, nb_staffs - 1)]
valid.status = "PENDING_V"
if to_do > 2: # publish content
valid.comment_validator = fake.text(max_nb_chars=80)
valid.status = "ACCEPT"
valid.date_validation = datetime.now()
content.sha_public = content.sha_draft
published = publish_content(content, versioned)
content.public_version = published
valid.save()
content.save()
def form_valid(self, form):
user = self.request.user
validation = Validation.objects.filter(pk=self.kwargs['pk']).last()
if not validation:
raise PermissionDenied
if validation.validator != user:
raise PermissionDenied
if validation.status != 'PENDING_V':
raise PermissionDenied
# get database representation and validated version
db_object = validation.content
versioned = db_object.load_version(sha=validation.version)
self.success_url = versioned.get_absolute_url(
version=validation.version)
is_update = db_object.sha_public
try:
published = publish_content(
db_object,
versioned,
is_major_update=form.cleaned_data['is_major'])
except FailureDuringPublication as e:
messages.error(self.request, e.message)
else:
save_validation_state(db_object,
is_update,
published,
validation,
versioned,
source=db_object.source,
is_major=form.cleaned_data['is_major'],
user=self.request.user,
request=self.request,
comment=form.cleaned_data['text'])
notify_update(db_object, is_update, form.cleaned_data['is_major'])
messages.success(self.request, _('Le contenu a bien été validé.'))
self.success_url = published.get_absolute_url_online()
return super(AcceptValidation, self).form_valid(form)
def test_publish_content_medium_tuto(self):
# 3. Medium-size tutorial
midsize_tuto = PublishableContentFactory(type='TUTORIAL')
midsize_tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=midsize_tuto.gallery, user=self.user_author, mode='W')
midsize_tuto.licence = self.licence
midsize_tuto.save()
# populate with 2 chapters (1 extract each)
midsize_tuto_draft = midsize_tuto.load_version()
chapter1 = ContainerFactory(parent=midsize_tuto_draft, db_objet=midsize_tuto)
ExtractFactory(container=chapter1, db_object=midsize_tuto)
chapter2 = ContainerFactory(parent=midsize_tuto_draft, db_objet=midsize_tuto)
ExtractFactory(container=chapter2, db_object=midsize_tuto)
# publish it
midsize_tuto = PublishableContent.objects.get(pk=midsize_tuto.pk)
published = publish_content(midsize_tuto, midsize_tuto_draft)
self.assertEqual(published.content, midsize_tuto)
self.assertEqual(published.content_pk, midsize_tuto.pk)
self.assertEqual(published.content_type, midsize_tuto.type)
self.assertEqual(published.content_public_slug, midsize_tuto_draft.slug)
self.assertEqual(published.sha_public, midsize_tuto.sha_draft)
public = midsize_tuto.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # it's a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test creation of files:
self.assertTrue(Path(published.get_prod_path()).is_dir())
self.assertTrue(Path(published.get_prod_path(), 'manifest.json').is_file())
self.assertTrue(Path(public.get_prod_path(), public.introduction).is_file())
self.assertTrue(Path(public.get_prod_path(), public.conclusion).is_file())
self.assertEqual(len(public.children), 2)
for child in public.children:
self.assertTrue(os.path.isfile(child.get_prod_path())) # an HTML file for each chapter
self.assertIsNone(child.introduction)
self.assertIsNone(child.conclusion)
def test_content_ordering(self):
category_1 = ContentCategoryFactory()
category_2 = ContentCategoryFactory()
subcategory_1 = SubCategoryFactory(category=category_1)
subcategory_1.position = 5
subcategory_1.save()
subcategory_2 = SubCategoryFactory(category=category_1)
subcategory_2.position = 1
subcategory_2.save()
subcategory_3 = SubCategoryFactory(category=category_2)
tuto_1 = PublishableContentFactory(type="TUTORIAL")
tuto_1.subcategory.add(subcategory_1)
tuto_1_draft = tuto_1.load_version()
publish_content(tuto_1, tuto_1_draft, is_major_update=True)
top_categories_tuto = topbar_publication_categories("TUTORIAL").get(
"categories")
expected = [(subcategory_1.title, subcategory_1.slug, category_1.slug)]
self.assertEqual(top_categories_tuto[category_1.title], expected)
tuto_2 = PublishableContentFactory(type="TUTORIAL")
tuto_2.subcategory.add(subcategory_2)
tuto_2_draft = tuto_2.load_version()
publish_content(tuto_2, tuto_2_draft, is_major_update=True)
top_categories_tuto = topbar_publication_categories("TUTORIAL").get(
"categories")
# New subcategory is now first is the list
expected.insert(
0, (subcategory_2.title, subcategory_2.slug, category_1.slug))
self.assertEqual(top_categories_tuto[category_1.title], expected)
article_1 = PublishableContentFactory(type="TUTORIAL")
article_1.subcategory.add(subcategory_3)
article_1_draft = tuto_2.load_version()
publish_content(article_1, article_1_draft, is_major_update=True)
# New article has no impact
top_categories_tuto = topbar_publication_categories("TUTORIAL").get(
"categories")
self.assertEqual(top_categories_tuto[category_1.title], expected)
top_categories_contents = topbar_publication_categories(
["TUTORIAL", "ARTICLE"]).get("categories")
expected_2 = [(subcategory_3.title, subcategory_3.slug,
category_2.slug)]
self.assertEqual(top_categories_contents[category_1.title], expected)
self.assertEqual(top_categories_contents[category_2.title], expected_2)
def test_move_no_slug_update(self):
"""
this test comes from issue #3328 (https://github.com/zestedesavoir/zds-site/issues/3328)
telling it is tricky is kind of euphemism.
:return:
"""
LicenceFactory(code='CC BY')
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
draft_zip_path = join(dirname(__file__), 'fake_lasynchrone-et-le-multithread-en-net.zip')
result = self.client.post(
reverse('content:import-new'),
{
'archive': open(draft_zip_path),
'subcategory': self.subcategory.pk
},
follow=False
)
self.assertEqual(result.status_code, 302)
tuto = PublishableContent.objects.last()
published = publish_content(tuto, tuto.load_version(), True)
tuto.sha_public = tuto.sha_draft
tuto.public_version = published
tuto.save()
extract1 = tuto.load_version().children[0]
# test moving up smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': extract1.slug,
'first_level_slug': '',
'container_slug': tuto.slug,
'moving_method': 'down',
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertTrue(isdir(tuto.get_repo_path()))
def test_move_no_slug_update(self):
"""
this test comes from issue #3328 (https://github.com/zestedesavoir/zds-site/issues/3328)
telling it is tricky is kind of euphemism.
:return:
"""
LicenceFactory(code='CC BY')
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
draft_zip_path = join(dirname(__file__), 'fake_lasynchrone-et-le-multithread-en-net.zip')
result = self.client.post(
reverse('content:import-new'),
{
'archive': open(draft_zip_path, 'rb'),
'subcategory': self.subcategory.pk
},
follow=False
)
self.assertEqual(result.status_code, 302)
tuto = PublishableContent.objects.last()
published = publish_content(tuto, tuto.load_version(), True)
tuto.sha_public = tuto.sha_draft
tuto.public_version = published
tuto.save()
extract1 = tuto.load_version().children[0]
# test moving up smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': extract1.slug,
'first_level_slug': '',
'container_slug': tuto.slug,
'moving_method': 'down',
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertTrue(isdir(tuto.get_repo_path()))
def test_char_count_after_publication(self):
"""Test the ``get_char_count()`` function.
Special care should be taken with this function, since:
- The username of the author is, by default "Firmxxx" where "xxx" depends on the tests before ;
- The titles (!) also contains a number that also depends on the number of tests before ;
- The date is ``datetime.now()`` and contains the months, which is never a fixed number of letters.
"""
author = ProfileFactory().user
author.username = '******'
author.save()
len_date_now = len(date(datetime.now(), 'd F Y'))
article = PublishedContentFactory(type='ARTICLE',
author_list=[author],
title='Un titre')
published = PublishedContent.objects.filter(content=article).first()
self.assertEqual(published.get_char_count(), 160 + len_date_now)
tuto = PublishableContentFactory(type='TUTORIAL',
author_list=[author],
title='Un titre')
# add a chapter, so it becomes a middle tutorial
tuto_draft = tuto.load_version()
chapter1 = ContainerFactory(parent=tuto_draft,
db_object=tuto,
title='Un chapitre')
ExtractFactory(container=chapter1, db_object=tuto, title='Un extrait')
published = publish_content(tuto, tuto_draft, is_major_update=True)
tuto.sha_public = tuto_draft.current_version
tuto.sha_draft = tuto_draft.current_version
tuto.public_version = published
tuto.save()
published = PublishedContent.objects.filter(content=tuto).first()
self.assertEqual(published.get_char_count(), 335 + len_date_now)
def test_mini_tuto(self):
"""
Test everything in a mini tuto is exported:
+ Content
+ Extract
+ Extract
"""
def check(path):
with path.open("r") as f:
content = f.read()
self.assertIn(mini_tuto_draft.get_introduction(), content)
self.assertIn(extract1.title, content)
self.assertIn(extract1.get_text(), content)
self.assertIn(extract2.title, content)
self.assertIn(extract2.get_text(), content)
self.assertIn(mini_tuto_draft.get_conclusion(), content)
mini_tuto, mini_tuto_draft = self.create_content()
extract1 = ExtractFactory(container=mini_tuto_draft,
db_object=mini_tuto,
title="Extract 1",
text_content="Content extract 1")
extract2 = ExtractFactory(container=mini_tuto_draft,
db_object=mini_tuto,
title="Extract 2",
text_content="Content extract 2")
# publish it
published = publish_content(mini_tuto, mini_tuto_draft)
# Test Markdown content:
self.assertTrue(published.has_md())
check(
Path(published.get_extra_contents_directory(),
published.content_public_slug + ".md"))
# PDF generation may fail, we only test the LaTeX content:
check(Path(self.get_latex_file_path(published)))
def test_move_no_slug_update(self):
"""
this test comes from issue #3328 (https://github.com/zestedesavoir/zds-site/issues/3328)
telling it is tricky is kind of euphemism.
:return:
"""
LicenceFactory(code="CC BY")
self.client.force_login(self.user_author)
draft_zip_path = join(dirname(__file__),
"fake_lasynchrone-et-le-multithread-en-net.zip")
result = self.client.post(
reverse("content:import-new"),
{
"archive": open(draft_zip_path, "rb"),
"subcategory": self.subcategory.pk
},
follow=False,
)
self.assertEqual(result.status_code, 302)
tuto = PublishableContent.objects.last()
published = publish_content(tuto, tuto.load_version(), True)
tuto.sha_public = tuto.sha_draft
tuto.public_version = published
tuto.save()
extract1 = tuto.load_version().children[0]
# test moving up smoothly
result = self.client.post(
reverse("content:move-element"),
{
"child_slug": extract1.slug,
"first_level_slug": "",
"container_slug": tuto.slug,
"moving_method": "down",
"pk": tuto.pk,
},
follow=True,
)
self.assertEqual(200, result.status_code)
self.assertTrue(isdir(tuto.get_repo_path()))
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.assertTrue(self.client.login(username=self.user1.username, password='******'))
def test_content_ordering(self):
category_1 = ContentCategoryFactory()
category_2 = ContentCategoryFactory()
subcategory_1 = SubCategoryFactory(category=category_1)
subcategory_1.position = 5
subcategory_1.save()
subcategory_2 = SubCategoryFactory(category=category_1)
subcategory_2.position = 1
subcategory_2.save()
subcategory_3 = SubCategoryFactory(category=category_2)
tuto_1 = PublishableContentFactory(type='TUTORIAL')
tuto_1.subcategory.add(subcategory_1)
tuto_1_draft = tuto_1.load_version()
publish_content(tuto_1, tuto_1_draft, is_major_update=True)
top_categories_tuto = topbar_publication_categories('TUTORIAL').get('categories')
expected = [(subcategory_1.title, subcategory_1.slug, category_1.slug)]
self.assertEqual(top_categories_tuto[category_1.title], expected)
tuto_2 = PublishableContentFactory(type='TUTORIAL')
tuto_2.subcategory.add(subcategory_2)
tuto_2_draft = tuto_2.load_version()
publish_content(tuto_2, tuto_2_draft, is_major_update=True)
top_categories_tuto = topbar_publication_categories('TUTORIAL').get('categories')
# New subcategory is now first is the list
expected.insert(0, (subcategory_2.title, subcategory_2.slug, category_1.slug))
self.assertEqual(top_categories_tuto[category_1.title], expected)
article_1 = PublishableContentFactory(type='TUTORIAL')
article_1.subcategory.add(subcategory_3)
article_1_draft = tuto_2.load_version()
publish_content(article_1, article_1_draft, is_major_update=True)
# New article has no impact
top_categories_tuto = topbar_publication_categories('TUTORIAL').get('categories')
self.assertEqual(top_categories_tuto[category_1.title], expected)
top_categories_contents = topbar_publication_categories(['TUTORIAL', 'ARTICLE']).get('categories')
expected_2 = [(subcategory_3.title, subcategory_3.slug, category_2.slug)]
self.assertEqual(top_categories_contents[category_1.title], expected)
self.assertEqual(top_categories_contents[category_2.title], expected_2)
def form_valid(self, form):
user = self.request.user
validation = Validation.objects.filter(pk=self.kwargs['pk']).last()
if not validation:
raise PermissionDenied
if validation.validator != user:
raise PermissionDenied
if validation.status != 'PENDING_V':
raise PermissionDenied
# get database representation and validated version
db_object = validation.content
versioned = db_object.load_version(sha=validation.version)
self.success_url = versioned.get_absolute_url(
version=validation.version)
is_update = db_object.sha_public
try:
published = publish_content(
db_object,
versioned,
is_major_update=form.cleaned_data['is_major'])
except FailureDuringPublication as e:
messages.error(self.request, e.message)
else:
# save in database
db_object.sha_public = validation.version
db_object.source = form.cleaned_data['source']
db_object.sha_validation = None
db_object.public_version = published
if form.cleaned_data[
'is_major'] or not is_update or db_object.pubdate is None:
db_object.pubdate = datetime.now()
db_object.save()
# save validation object
validation.comment_validator = form.cleaned_data['text']
validation.status = "ACCEPT"
validation.date_validation = datetime.now()
validation.save()
for user in db_object.authors.all():
read = ContentRead.objects.filter(content__pk=db_object.pk,
user__pk=user.pk).first()
if read is None:
read = ContentRead()
read.user = user
read.content = db_object
read.save()
if is_update:
msg = render_to_string(
'tutorialv2/messages/validation_accept_update.md', {
'content': versioned,
'url': published.get_absolute_url_online(),
'validator': validation.validator
})
else:
msg = render_to_string(
'tutorialv2/messages/validation_accept_content.md', {
'content': versioned,
'url': published.get_absolute_url_online(),
'validator': validation.validator
})
bot = get_object_or_404(
User, username=settings.ZDS_APP['member']['bot_account'])
send_mp(bot,
db_object.authors.all(),
_(u"Publication acceptée"),
versioned.title,
msg,
True,
direct=False)
messages.success(self.request, _(u'Le contenu a bien été validé.'))
self.success_url = published.get_absolute_url_online()
return super(AcceptValidation, self).form_valid(form)
def load_contents(cli, _type, size, fake):
"""Create v2 contents"""
nb_contents = size * 10
percent_contents_in_validation = 0.4
percent_contents_with_validator = 0.2
percent_contents_public = 0.3
percent_mini = 0.5
percent_medium = 0.3
percent_big = 0.2
nb_avg_containers_in_content = size
nb_avg_extracts_in_content = size
is_articles = _type == "ARTICLE"
is_tutorials = not is_articles
textual_type = u"article"
if is_tutorials:
textual_type = u"tutoriel"
# small introduction
cli.stdout.write(u'À créer: {:d} {}s'.format(nb_contents, textual_type), ending='')
if is_tutorials:
cli.stdout.write(u' ({:g} petits, {:g} moyens et {:g} grands)'
.format(nb_contents * percent_mini, nb_contents * percent_medium, nb_contents * percent_big))
else:
cli.stdout.write('')
cli.stdout.write(
u' - {:g} en brouillon'.format(
nb_contents *
(1 - percent_contents_public - percent_contents_in_validation - percent_contents_with_validator)))
cli.stdout.write(
u' - {:g} en validation (dont {:g} réservés)'
.format(nb_contents * (percent_contents_in_validation + percent_contents_with_validator),
nb_contents * percent_contents_with_validator))
cli.stdout.write(u' - {:g} publiés'.format(nb_contents * percent_contents_public))
tps1 = time.time()
# create tables with 0=draft, 1=in validation, 2=reserved, 3=published
what_to_do = []
for i in range(nb_contents):
what = 0 # in draft
if i < percent_contents_public * nb_contents:
what = 3
elif i < (percent_contents_public + percent_contents_with_validator) * nb_contents:
what = 2
elif i >= (1 - percent_contents_in_validation) * nb_contents:
what = 1
what_to_do.append(what)
# create a table with 0=mini, 1=medium, 2=big
content_sizes = []
for i in range(nb_contents):
sz = 0
if i < percent_big * nb_contents:
sz = 2
elif i >= (1 - percent_medium) * nb_contents:
sz = 1
content_sizes.append(sz)
# shuffle the whole thing
random.shuffle(what_to_do)
random.shuffle(content_sizes)
# checks that everything is ok
users = list(Profile.objects.all())
nb_users = len(users)
sub_categories = list(SubCategory.objects.all())
nb_sub_categories = len(sub_categories)
if nb_users == 0:
cli.stdout.write(u"Il n'y a aucun membre actuellement. "
u"Vous devez rajouter les membre dans vos fixtures (member)")
return
if nb_sub_categories == 0:
cli.stdout.write(u"Il n'y a aucune catégories actuellement."
u"Vous devez rajouter les catégories dans vos fixtures (category_content)")
return
perms = list(Permission.objects.filter(codename__startswith='change_').all())
staffs = list(User.objects.filter(groups__permissions__in=perms).all())
nb_staffs = len(staffs)
if nb_staffs == 0:
cli.stdout.write(u"Il n'y a aucun staff actuellement."
u"Vous devez rajouter les staffs dans vos fixtures (staff)")
return
licenses = list(Licence.objects.all())
nb_licenses = len(licenses)
if nb_licenses == 0:
cli.stdout.write(u"Il n'y a aucune licence actuellement."
u"Vous devez rajouter les licences dans vos fixtures (category_content)")
return
# create and so all:
for i in range(nb_contents):
sys.stdout.write("Création {} : {}/{} \r".format(textual_type, i + 1, nb_contents))
current_size = content_sizes[i]
to_do = what_to_do[i]
# creation:
content = PublishableContentFactory(
type=_type,
title=fake.text(max_nb_chars=60),
description=fake.sentence(nb_words=15, variable_nb_words=True))
versioned = content.load_version()
if current_size == 0 or is_articles:
for j in range(random.randint(1, nb_avg_extracts_in_content * 2)):
ExtractFactory(container=versioned, title=fake.text(max_nb_chars=60), light=False)
else:
for j in range(random.randint(1, nb_avg_containers_in_content * 2)):
container = ContainerFactory(parent=versioned, title=fake.text(max_nb_chars=60))
if current_size == 1: # medium size tutorial
for k in range(random.randint(1, nb_avg_extracts_in_content * 2)):
ExtractFactory(container=container, title=fake.text(max_nb_chars=60), light=False)
else: # big-size tutorial
for k in range(random.randint(1, nb_avg_containers_in_content * 2)):
subcontainer = ContainerFactory(parent=container, title=fake.text(max_nb_chars=60))
for l in range(random.randint(1, nb_avg_extracts_in_content * 2)):
ExtractFactory(container=subcontainer, title=fake.text(max_nb_chars=60), light=False)
# add some informations:
author = users[random.randint(0, nb_users - 1)].user
content.authors.add(author)
UserGalleryFactory(gallery=content.gallery, mode="W", user=author)
content.licence = licenses[random.randint(0, nb_licenses - 1)]
content.sha_draft = versioned.sha_draft
content.subcategory.add(sub_categories[random.randint(0, nb_sub_categories - 1)])
content.save()
# then, validation if needed:
if to_do > 0:
valid = CValidation(
content=content, version=content.sha_draft, date_proposition=datetime.now(), status="PENDING")
valid.comment_validator = fake.text(max_nb_chars=200)
content.sha_validation = content.sha_draft
if to_do > 1: # reserve validation
valid.date_reserve = datetime.now()
valid.validator = staffs[random.randint(0, nb_staffs - 1)]
valid.status = "PENDING_V"
if to_do > 2: # publish content
valid.comment_validator = fake.text(max_nb_chars=80)
valid.status = "ACCEPT"
valid.date_validation = datetime.now()
content.sha_public = content.sha_draft
published = publish_content(content, versioned)
content.public_version = published
valid.save()
content.save()
sys.stdout.flush()
tps2 = time.time()
cli.stdout.write(u"\nFait en {:.3f} sec".format(tps2 - tps1))
def test_publish_content(self):
"""test and ensure the behavior of ``publish_content()`` and ``unpublish_content()``"""
# 1. Article:
article = PublishableContentFactory(type='ARTICLE')
article.authors.add(self.user_author)
UserGalleryFactory(gallery=article.gallery, user=self.user_author, mode='W')
article.licence = self.licence
article.save()
# populate the article
article_draft = article.load_version()
ExtractFactory(container=article_draft, db_object=article)
ExtractFactory(container=article_draft, db_object=article)
self.assertEqual(len(article_draft.children), 2)
# publish !
article = PublishableContent.objects.get(pk=article.pk)
published = publish_content(article, article_draft)
self.assertEqual(published.content, article)
self.assertEqual(published.content_pk, article.pk)
self.assertEqual(published.content_type, article.type)
self.assertEqual(published.content_public_slug, article_draft.slug)
self.assertEqual(published.sha_public, article.sha_draft)
public = article.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # its a PublicContent object !
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test object created in database
self.assertEqual(PublishedContent.objects.filter(content=article).count(), 1)
published = PublishedContent.objects.filter(content=article).last()
self.assertEqual(published.content_pk, article.pk)
self.assertEqual(published.content_public_slug, article_draft.slug)
self.assertEqual(published.content_type, article.type)
self.assertEqual(published.sha_public, public.current_version)
# test creation of files:
self.assertTrue(os.path.isdir(published.get_prod_path()))
self.assertTrue(os.path.isfile(os.path.join(published.get_prod_path(), 'manifest.json')))
self.assertTrue(os.path.isfile(public.get_prod_path())) # normally, an HTML file should exists
self.assertIsNone(public.introduction) # since all is in the HTML file, introduction does not exists anymore
self.assertIsNone(public.conclusion)
article.public_version = published
article.save()
# depublish it !
unpublish_content(article)
self.assertEqual(PublishedContent.objects.filter(content=article).count(), 0) # published object disappear
self.assertFalse(os.path.exists(public.get_prod_path())) # article was removed
# ... For the next tests, I will assume that the unpublication works.
# 2. Mini-tutorial → Not tested, because at this point, it's the same as an article (with a different metadata)
# 3. Medium-size tutorial
midsize_tuto = PublishableContentFactory(type='TUTORIAL')
midsize_tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=midsize_tuto.gallery, user=self.user_author, mode='W')
midsize_tuto.licence = self.licence
midsize_tuto.save()
# populate with 2 chapters (1 extract each)
midsize_tuto_draft = midsize_tuto.load_version()
chapter1 = ContainerFactory(parent=midsize_tuto_draft, db_objet=midsize_tuto)
ExtractFactory(container=chapter1, db_object=midsize_tuto)
chapter2 = ContainerFactory(parent=midsize_tuto_draft, db_objet=midsize_tuto)
ExtractFactory(container=chapter2, db_object=midsize_tuto)
# publish it
midsize_tuto = PublishableContent.objects.get(pk=midsize_tuto.pk)
published = publish_content(midsize_tuto, midsize_tuto_draft)
self.assertEqual(published.content, midsize_tuto)
self.assertEqual(published.content_pk, midsize_tuto.pk)
self.assertEqual(published.content_type, midsize_tuto.type)
self.assertEqual(published.content_public_slug, midsize_tuto_draft.slug)
self.assertEqual(published.sha_public, midsize_tuto.sha_draft)
public = midsize_tuto.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # its a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test creation of files:
self.assertTrue(os.path.isdir(published.get_prod_path()))
self.assertTrue(os.path.isfile(os.path.join(published.get_prod_path(), 'manifest.json')))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.introduction)))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.conclusion)))
self.assertEqual(len(public.children), 2)
for child in public.children:
self.assertTrue(os.path.isfile(child.get_prod_path())) # an HTML file for each chapter
self.assertIsNone(child.introduction)
self.assertIsNone(child.conclusion)
# 4. Big tutorial:
bigtuto = PublishableContentFactory(type='TUTORIAL')
bigtuto.authors.add(self.user_author)
UserGalleryFactory(gallery=bigtuto.gallery, user=self.user_author, mode='W')
bigtuto.licence = self.licence
bigtuto.save()
# populate with 2 part (1 chapter with 1 extract each)
bigtuto_draft = bigtuto.load_version()
part1 = ContainerFactory(parent=bigtuto_draft, db_objet=bigtuto)
chapter1 = ContainerFactory(parent=part1, db_objet=bigtuto)
ExtractFactory(container=chapter1, db_object=bigtuto)
part2 = ContainerFactory(parent=bigtuto_draft, db_objet=bigtuto)
chapter2 = ContainerFactory(parent=part2, db_objet=bigtuto)
ExtractFactory(container=chapter2, db_object=bigtuto)
# publish it
bigtuto = PublishableContent.objects.get(pk=bigtuto.pk)
published = publish_content(bigtuto, bigtuto_draft)
self.assertEqual(published.content, bigtuto)
self.assertEqual(published.content_pk, bigtuto.pk)
self.assertEqual(published.content_type, bigtuto.type)
self.assertEqual(published.content_public_slug, bigtuto_draft.slug)
self.assertEqual(published.sha_public, bigtuto.sha_draft)
public = bigtuto.load_version(sha=published.sha_public, public=published)
self.assertIsNotNone(public)
self.assertTrue(public.PUBLIC) # its a PublicContent object
self.assertEqual(public.type, published.content_type)
self.assertEqual(public.current_version, published.sha_public)
# test creation of files:
self.assertTrue(os.path.isdir(published.get_prod_path()))
self.assertTrue(os.path.isfile(os.path.join(published.get_prod_path(), 'manifest.json')))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.introduction)))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), public.conclusion)))
self.assertEqual(len(public.children), 2)
for part in public.children:
self.assertTrue(os.path.isdir(part.get_prod_path())) # a directory for each part
# ... and an HTML file for introduction and conclusion
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), part.introduction)))
self.assertTrue(os.path.isfile(os.path.join(public.get_prod_path(), part.conclusion)))
self.assertEqual(len(part.children), 1)
for chapter in part.children:
# the HTML file is located in the good directory:
self.assertEqual(part.get_prod_path(), os.path.dirname(chapter.get_prod_path()))
self.assertTrue(os.path.isfile(chapter.get_prod_path())) # an HTML file for each chapter
self.assertIsNone(chapter.introduction)
self.assertIsNone(chapter.conclusion)
def test_filters(self):
""" Test filtering by category & tag """
subcategory2 = SubCategoryFactory()
subcategory3 = SubCategoryFactory()
tag2 = TagFactory()
tag3 = TagFactory()
# Add a new tuto & publish it
article2 = PublishableContentFactory(type="ARTICLE")
article2.authors.add(self.user_author)
article2.licence = self.licence
article2.subcategory.add(subcategory2)
article2.tags.add(self.tag)
article2.tags.add(tag2)
article2.save()
article2_draft = article2.load_version()
article2.sha_public = article2.sha_draft = article2_draft.current_version
article2.public_version = publish_content(article2,
article2_draft,
is_major_update=True)
article2.save()
# Default view
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [article2, self.article])
# Filter by subcategory
self.articlefeed.query_params = {"subcategory": self.subcategory.slug}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [self.article])
self.articlefeed.query_params = {
"subcategory": f" {self.subcategory.slug} "
}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [self.article])
self.articlefeed.query_params = {"subcategory": subcategory2.slug}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [article2])
self.articlefeed.query_params = {"subcategory": subcategory3.slug}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [])
self.articlefeed.query_params = {"subcategory": "invalid"}
self.assertRaises(Http404, self.articlefeed.items)
# Filter by tag
self.articlefeed.query_params = {"tag": self.tag.slug}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [article2, self.article])
self.articlefeed.query_params = {"tag": tag2.slug}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [article2])
self.articlefeed.query_params = {"tag": f" {tag2.slug} "}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [article2])
self.articlefeed.query_params = {"tag": tag3.slug}
ret = [item.content for item in self.articlefeed.items()]
self.assertEqual(ret, [])
self.articlefeed.query_params = {"tag": "invalid"}
self.assertRaises(Http404, self.articlefeed.items)
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 form_valid(self, form):
user = self.request.user
validation = Validation.objects.filter(pk=self.kwargs['pk']).last()
if not validation:
raise PermissionDenied
if validation.validator != user:
raise PermissionDenied
if validation.status != 'PENDING_V':
raise PermissionDenied
# get database representation and validated version
db_object = validation.content
versioned = db_object.load_version(sha=validation.version)
self.success_url = versioned.get_absolute_url(
version=validation.version)
is_update = db_object.sha_public
try:
published = publish_content(
db_object,
versioned,
is_major_update=form.cleaned_data['is_major'])
except FailureDuringPublication as e:
messages.error(self.request, e.message)
else:
# save in database
db_object.sha_public = validation.version
db_object.source = form.cleaned_data['source']
db_object.sha_validation = None
db_object.public_version = published
if form.cleaned_data[
'is_major'] or not is_update or db_object.pubdate is None:
db_object.pubdate = datetime.now()
db_object.is_obsolete = False
# close beta if is an article
if db_object.type == 'ARTICLE':
db_object.sha_beta = None
topic = db_object.beta_topic
if topic is not None and not topic.is_locked:
msg_post = render_to_string(
'tutorialv2/messages/beta_desactivate.md',
{'content': versioned})
send_post(self.request, topic, self.request.user, msg_post)
lock_topic(topic)
db_object.save()
# save validation object
validation.comment_validator = form.cleaned_data['text']
validation.status = 'ACCEPT'
validation.date_validation = datetime.now()
validation.save()
# Follow
signals.new_content.send(sender=db_object.__class__,
instance=db_object,
by_email=False)
messages.success(self.request, _('Le contenu a bien été validé.'))
self.success_url = published.get_absolute_url_online()
return super(AcceptValidation, self).form_valid(form)
def test_es_manager(self):
"""Test the behavior of the ``es_manager`` command"""
if not self.index_manager.connected_to_es:
return
# in the beginning: the void
self.assertTrue(self.index_manager.index not in self.index_manager.es.cat.indices())
text = 'Ceci est un texte de test'
# create a topic with a post
topic = TopicFactory(forum=self.forum, author=self.user, title=text)
post = PostFactory(topic=topic, author=self.user, position=1)
post.text = post.text_html = text
post.save()
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertFalse(topic.es_already_indexed)
self.assertTrue(topic.es_flagged)
self.assertFalse(post.es_already_indexed)
self.assertTrue(post.es_flagged)
# create a middle-tutorial and publish it
tuto = PublishableContentFactory(type='TUTORIAL')
tuto.authors.add(self.user)
tuto.save()
tuto_draft = tuto.load_version()
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter1.repo_update(text, text, text)
extract1 = ExtractFactory(container=chapter1, db_object=tuto)
version = extract1.repo_update(text, text)
published = publish_content(tuto, tuto_draft, is_major_update=True)
tuto.sha_public = version
tuto.sha_draft = version
tuto.public_version = published
tuto.save()
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertFalse(published.es_already_indexed)
self.assertTrue(published.es_flagged)
# 1. test "index-all"
call_command('es_manager', 'index_all')
self.assertTrue(self.index_manager.es.indices.exists(self.index_manager.index))
self.index_manager.index_exists = True
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertTrue(topic.es_already_indexed)
self.assertFalse(topic.es_flagged)
self.assertTrue(post.es_already_indexed)
self.assertFalse(post.es_flagged)
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertTrue(published.es_already_indexed)
self.assertFalse(published.es_flagged)
s = Search()
s.query(MatchAll())
results = self.index_manager.setup_search(s).execute()
self.assertEqual(len(results), 4) # get 4 results, one of each type
must_contain = {'post': False, 'topic': False, 'publishedcontent': False, 'chapter': False}
id_must_be = {
'post': str(post.pk),
'topic': str(topic.pk),
'publishedcontent': str(published.pk),
'chapter': tuto.slug + '__' + chapter1.slug
}
for hit in results:
doc_type = hit.meta.doc_type
must_contain[doc_type] = True
self.assertEqual(hit.meta.id, id_must_be[doc_type])
self.assertTrue(all(must_contain))
# 2. test "clear"
self.assertTrue(self.index_manager.index in self.index_manager.es.cat.indices()) # index in
call_command('es_manager', 'clear')
self.assertFalse(self.index_manager.es.indices.exists(self.index_manager.index))
self.index_manager.index_exists = False
# must reset every object
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertFalse(topic.es_already_indexed)
self.assertTrue(topic.es_flagged)
self.assertFalse(post.es_already_indexed)
self.assertTrue(post.es_flagged)
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertFalse(published.es_already_indexed)
self.assertTrue(published.es_flagged)
self.assertTrue(self.index_manager.index not in self.index_manager.es.cat.indices()) # index wiped out !
# 3. test "setup"
call_command('es_manager', 'setup')
self.assertTrue(self.index_manager.es.indices.exists(self.index_manager.index))
self.index_manager.index_exists = True
self.assertTrue(self.index_manager.index in self.index_manager.es.cat.indices()) # index back in ...
s = Search()
s.query(MatchAll())
results = self.index_manager.setup_search(s).execute()
self.assertEqual(len(results), 0) # ... but with nothing in it
result = self.index_manager.es.indices.get_settings(index=self.index_manager.index)
settings_index = result[self.index_manager.index]['settings']['index']
self.assertTrue('analysis' in settings_index) # custom analyzer was setup
# 4. test "index-flagged" once ...
call_command('es_manager', 'index_flagged')
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertTrue(topic.es_already_indexed)
self.assertFalse(topic.es_flagged)
self.assertTrue(post.es_already_indexed)
self.assertFalse(post.es_flagged)
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertTrue(published.es_already_indexed)
self.assertFalse(published.es_flagged)
s = Search()
s.query(MatchAll())
results = self.index_manager.setup_search(s).execute()
self.assertEqual(len(results), 4) # get the 4 results back
def test_export_only_ready_to_publish(self):
"""
Test exported contents contain only ready_to_publish==True parts.
"""
# We save the current settings for the PDF publicator:
previous_pdf_publicator = PublicatorRegistry.get("pdf")
previous_build_pdf_when_published = self.overridden_zds_app["content"][
"build_pdf_when_published"]
# We need to produce at least the LaTeX file, so we use the real PDF publicator:
PublicatorRegistry.registry["pdf"] = ZMarkdownRebberLatexPublicator(
".pdf")
self.overridden_zds_app["content"]["build_pdf_when_published"] = True
# Medium-size tutorial
midsize_tuto = PublishableContentFactory(type="TUTORIAL")
midsize_tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=midsize_tuto.gallery,
user=self.user_author,
mode="W")
midsize_tuto.licence = self.licence
midsize_tuto.save()
# populate with 3 chapters (1 extract each), one not being ready for pubication
midsize_tuto_draft = midsize_tuto.load_version()
chapter1 = ContainerFactory(parent=midsize_tuto_draft,
db_object=midsize_tuto,
title="Chapter 1 ready")
ExtractFactory(container=chapter1, db_object=midsize_tuto)
chapter2 = ContainerFactory(parent=midsize_tuto_draft,
db_object=midsize_tuto,
title="Chapter 2 ready")
ExtractFactory(container=chapter2, db_object=midsize_tuto)
chapter3 = ContainerFactory(parent=midsize_tuto_draft,
db_object=midsize_tuto,
title="Chapter 3 not ready")
chapter3.ready_to_publish = False
ExtractFactory(container=chapter3, db_object=midsize_tuto)
# publish it
midsize_tuto = PublishableContent.objects.get(pk=midsize_tuto.pk)
published = publish_content(midsize_tuto, midsize_tuto_draft)
public = midsize_tuto.load_version(sha=published.sha_public,
public=published)
# test creation of files:
self.assertTrue(Path(published.get_prod_path()).is_dir())
self.assertTrue(
Path(published.get_prod_path(), "manifest.json").is_file())
self.assertTrue(
Path(public.get_prod_path(), public.introduction).is_file())
self.assertTrue(
Path(public.get_prod_path(), public.conclusion).is_file())
self.assertEqual(len(public.children), 2)
for child in public.children:
self.assertTrue(os.path.isfile(
child.get_prod_path())) # an HTML file for each chapter
self.assertIsNone(child.introduction)
self.assertIsNone(child.conclusion)
# Test Markdown content:
self.assertTrue(published.has_md())
with Path(published.get_extra_contents_directory(),
published.content_public_slug + ".md").open("r") as md:
content = md.read()
self.assertIn(chapter1.title, content)
self.assertIn(chapter2.title, content)
self.assertNotIn(chapter3.title, content)
# TODO: factorize getting the LaTeX file path with what is done in zds.tutorialv2.publication_utils.publish_content()
tmp_path = os.path.join(
settings.ZDS_APP["content"]["repo_public_path"],
published.content_public_slug + "__building")
build_extra_contents_path = os.path.join(
tmp_path, settings.ZDS_APP["content"]["extra_contents_dirname"])
base_name = os.path.join(build_extra_contents_path,
published.content_public_slug)
tex_file = base_name + ".tex"
# PDF generation may fail, we only test the LaTeX content:
with open(tex_file) as tex:
content = tex.read()
self.assertIn(chapter1.title, content)
self.assertIn(chapter2.title, content)
self.assertNotIn(chapter3.title, content)
# We set back the previous settings:
PublicatorRegistry.registry["pdf"] = previous_pdf_publicator
self.overridden_zds_app["content"][
"build_pdf_when_published"] = previous_build_pdf_when_published
def test_es_manager(self):
"""Test the behavior of the ``es_manager`` command"""
if not self.index_manager.connected_to_es:
return
# in the beginning: the void
self.assertTrue(self.index_manager.index not in self.index_manager.es.cat.indices())
text = "Ceci est un texte de test"
# create a topic with a post
topic = TopicFactory(forum=self.forum, author=self.user, title=text)
post = PostFactory(topic=topic, author=self.user, position=1)
post.text = post.text_html = text
post.save()
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertFalse(topic.es_already_indexed)
self.assertTrue(topic.es_flagged)
self.assertFalse(post.es_already_indexed)
self.assertTrue(post.es_flagged)
# create a middle-tutorial and publish it
tuto = PublishableContentFactory(type="TUTORIAL")
tuto.authors.add(self.user)
tuto.save()
tuto_draft = tuto.load_version()
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter1.repo_update(text, text, text)
extract1 = ExtractFactory(container=chapter1, db_object=tuto)
version = extract1.repo_update(text, text)
published = publish_content(tuto, tuto_draft, is_major_update=True)
tuto.sha_public = version
tuto.sha_draft = version
tuto.public_version = published
tuto.save()
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertFalse(published.es_already_indexed)
self.assertTrue(published.es_flagged)
# 1. test "index-all"
call_command("es_manager", "index_all")
self.assertTrue(self.index_manager.es.indices.exists(self.index_manager.index))
self.index_manager.index_exists = True
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertTrue(topic.es_already_indexed)
self.assertFalse(topic.es_flagged)
self.assertTrue(post.es_already_indexed)
self.assertFalse(post.es_flagged)
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertTrue(published.es_already_indexed)
self.assertFalse(published.es_flagged)
s = Search()
s.query(MatchAll())
results = self.index_manager.setup_search(s).execute()
self.assertEqual(len(results), 4) # get 4 results, one of each type
must_contain = {"post": False, "topic": False, "publishedcontent": False, "chapter": False}
id_must_be = {
"post": str(post.pk),
"topic": str(topic.pk),
"publishedcontent": str(published.pk),
"chapter": tuto.slug + "__" + chapter1.slug,
}
for hit in results:
doc_type = hit.meta.doc_type
must_contain[doc_type] = True
self.assertEqual(hit.meta.id, id_must_be[doc_type])
self.assertTrue(all(must_contain))
# 2. test "clear"
self.assertTrue(self.index_manager.index in self.index_manager.es.cat.indices()) # index in
call_command("es_manager", "clear")
self.assertFalse(self.index_manager.es.indices.exists(self.index_manager.index))
self.index_manager.index_exists = False
# must reset every object
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertFalse(topic.es_already_indexed)
self.assertTrue(topic.es_flagged)
self.assertFalse(post.es_already_indexed)
self.assertTrue(post.es_flagged)
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertFalse(published.es_already_indexed)
self.assertTrue(published.es_flagged)
self.assertTrue(self.index_manager.index not in self.index_manager.es.cat.indices()) # index wiped out !
# 3. test "setup"
call_command("es_manager", "setup")
self.assertTrue(self.index_manager.es.indices.exists(self.index_manager.index))
self.index_manager.index_exists = True
self.assertTrue(self.index_manager.index in self.index_manager.es.cat.indices()) # index back in ...
s = Search()
s.query(MatchAll())
results = self.index_manager.setup_search(s).execute()
self.assertEqual(len(results), 0) # ... but with nothing in it
result = self.index_manager.es.indices.get_settings(index=self.index_manager.index)
settings_index = result[self.index_manager.index]["settings"]["index"]
self.assertTrue("analysis" in settings_index) # custom analyzer was setup
# 4. test "index-flagged" once ...
call_command("es_manager", "index_flagged")
topic = Topic.objects.get(pk=topic.pk)
post = Post.objects.get(pk=post.pk)
self.assertTrue(topic.es_already_indexed)
self.assertFalse(topic.es_flagged)
self.assertTrue(post.es_already_indexed)
self.assertFalse(post.es_flagged)
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertTrue(published.es_already_indexed)
self.assertFalse(published.es_flagged)
s = Search()
s.query(MatchAll())
results = self.index_manager.setup_search(s).execute()
self.assertEqual(len(results), 4) # get the 4 results back
def _create_and_publish_type_in_subcategory(self, content_type, subcategory):
tuto_1 = PublishableContentFactory(type=content_type, author_list=[self.user_author])
tuto_1.subcategory.add(subcategory)
tuto_1.save()
tuto_1_draft = tuto_1.load_version()
publish_content(tuto_1, tuto_1_draft, is_major_update=True)