def get_published_content(self,
author,
user_staff,
nb_part=1,
nb_chapter=1,
nb_extract=1):
bigtuto = PublishableContentFactory(type='TUTORIAL')
bigtuto.authors.add(author)
UserGalleryFactory(gallery=bigtuto.gallery, user=author, mode='W')
bigtuto.licence = LicenceFactory()
bigtuto.save()
# populate the bigtuto
bigtuto_draft = bigtuto.load_version()
for i in range(nb_part):
part = ContainerFactory(parent=bigtuto_draft, db_object=bigtuto)
for j in range(nb_chapter):
chapter = ContainerFactory(parent=part, db_object=bigtuto)
for k in range(nb_extract):
ExtractFactory(container=chapter, db_object=bigtuto)
# connect with author:
self.client.login(username=author, password='******')
# ask validation
self.client.post(reverse('validation:ask',
kwargs={
'pk': bigtuto.pk,
'slug': bigtuto.slug
}), {
'text': 'ask for validation',
'source': '',
'version': bigtuto_draft.current_version
},
follow=False)
# login with staff and publish
self.client.login(username=user_staff.username, password='******')
validation = Validation.objects.filter(content=bigtuto).last()
self.client.post(reverse('validation:reserve',
kwargs={'pk': validation.pk}),
{'version': validation.version},
follow=False)
# accept
self.client.post(reverse('validation:accept',
kwargs={'pk': validation.pk}), {
'text': 'accept validation',
'is_major': True,
'source': ''
},
follow=False)
self.client.logout()
published = PublishedContent.objects.filter(content=bigtuto).first()
self.assertIsNotNone(published)
return published
def setUp(self):
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
self.overridden_zds_app["member"]["bot_account"] = self.mas.username
self.licence = LicenceFactory()
self.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type="TUTORIAL")
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery,
user=self.user_author,
mode="W")
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft,
db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1,
db_object=self.tuto)
self.extract1 = ExtractFactory(container=self.chapter1,
db_object=self.tuto)
def setUp(self):
self.overridden_zds_app = overridden_zds_app
self.mas = ProfileFactory().user
overridden_zds_app['member']['bot_account'] = self.mas.username
self.licence = LicenceFactory()
self.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type='TUTORIAL')
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery,
user=self.user_author,
mode='W')
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft,
db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1,
db_object=self.tuto)
self.old_registry = {
key: value
for key, value in PublicatorRegistery.get_all_registered()
}
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):
self.mas = ProfileFactory().user
self.overridden_zds_app["member"]["bot_account"] = self.mas.username
self.licence = LicenceFactory()
self.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type="TUTORIAL")
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery, user=self.user_author, mode="W")
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.old_registry = {key: value for key, value in PublicatorRegistry.get_all_registered()}
class TestPdfPublicator(Publicator):
def publish(self, md_file_path, base_name, **kwargs):
with Path(base_name + ".pdf").open("w") as f:
f.write("bla")
shutil.copy2(str(Path(base_name + ".pdf")), str(Path(md_file_path.replace("__building", "")).parent))
PublicatorRegistry.registry["pdf"] = TestPdfPublicator()
def setUp(self):
# don't build PDF to speed up the tests
settings.ZDS_APP['content']['build_pdf_when_published'] = False
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.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type='TUTORIAL')
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery,
user=self.user_author,
mode='W')
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft,
db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1,
db_object=self.tuto)
def test_move_container_after(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.chapter3 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.extract5 = ExtractFactory(container=self.chapter3, db_object=self.tuto)
self.chapter4 = ContainerFactory(parent=self.part2, db_object=self.tuto)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for container (smoothly)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter3.slug,
'container_slug': self.part1.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(1, len(chapter.children))
self.assertTrue(isfile(chapter.children[0].get_path()))
self.assertEqual(self.extract5.slug, chapter.children[0].slug)
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test changing parent for too deep container
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
def test_get_target_tagged_tree_for_container(self):
part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title='part2')
part3 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title='part3')
tagged_tree = get_target_tagged_tree_for_container(self.part1, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertFalse(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertFalse(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], 'can be moved after or before part2')
self.assertTrue(paths[part3.get_path(True)], 'can be moved after or before part3')
tagged_tree = get_target_tagged_tree_for_container(part3, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertTrue(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertTrue(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], 'can be moved after or before part2')
self.assertFalse(paths[part3.get_path(True)], 'can be moved after or before part3')
def setUp(self):
self.mas = ProfileFactory().user
self.overridden_zds_app['member']['bot_account'] = self.mas.username
self.licence = LicenceFactory()
self.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type='TUTORIAL')
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery, user=self.user_author, mode='W')
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.old_registry = {key: value for key, value in PublicatorRegistry.get_all_registered()}
class TestPdfPublicator(Publicator):
def publish(self, md_file_path, base_name, **kwargs):
with Path(base_name + '.pdf').open('w') as f:
f.write('bla')
shutil.copy2(str(Path(base_name + '.pdf')),
str(Path(md_file_path.replace('__building', '')).parent))
PublicatorRegistry.registry['pdf'] = TestPdfPublicator()
def setUp(self):
self.overridden_zds_app = overridden_zds_app
# don't build PDF to speed up the tests
overridden_zds_app["content"]["build_pdf_when_published"] = False
self.staff = StaffProfileFactory().user
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
overridden_zds_app["member"]["bot_account"] = self.mas.username
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory(category=CategoryFactory())
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
self.content = PublishableContentFactory(
author_list=[self.user_author], light=False)
self.part_published = ContainerFactory(
db_object=self.content,
light=False,
parent=self.content.load_version())
self.ignored_part = ContainerFactory(
db_object=self.content,
light=False,
parent=self.content.load_version())
ExtractFactory(db_object=self.content,
container=self.part_published,
light=False)
ExtractFactory(db_object=self.content,
container=self.ignored_part,
light=False)
def test_ensure_unique_slug(self):
"""
Ensure that slugs for a container or extract are always unique
"""
# get draft version
versioned = self.tuto.load_version()
# forbidden slugs:
slug_to_test = ['introduction', 'conclusion']
for slug in slug_to_test:
new_slug = versioned.get_unique_slug(slug)
self.assertNotEqual(slug, new_slug)
self.assertTrue(new_slug in versioned.slug_pool) # ensure new slugs are in slug pool
# then test with 'real' containers and extracts:
new_chapter_1 = ContainerFactory(title='aa', parent=versioned, db_object=self.tuto)
new_chapter_2 = ContainerFactory(title='aa', parent=versioned, db_object=self.tuto)
self.assertNotEqual(new_chapter_1.slug, new_chapter_2.slug)
new_extract_1 = ExtractFactory(title='aa', container=new_chapter_1, db_object=self.tuto)
self.assertEqual(new_extract_1.slug, new_chapter_1.slug) # different level can have the same slug!
new_extract_2 = ExtractFactory(title='aa', container=new_chapter_2, db_object=self.tuto)
self.assertEqual(new_extract_2.slug, new_extract_1.slug) # not the same parent, so allowed
new_extract_3 = ExtractFactory(title='aa', container=new_chapter_1, db_object=self.tuto)
self.assertNotEqual(new_extract_3.slug, new_extract_1.slug) # same parent, forbidden
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 test_tagged_tree_extract(self):
midsize = PublishableContentFactory(author_list=[self.user_author])
midsize_draft = midsize.load_version()
first_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
second_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
first_extract = ExtractFactory(container=first_container, db_object=midsize)
second_extract = ExtractFactory(container=second_container, db_object=midsize)
tagged_tree = get_target_tagged_tree_for_extract(first_extract, midsize_draft)
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(paths[second_extract.get_full_slug()])
self.assertFalse(paths[second_container.get_path(True)])
self.assertFalse(paths[first_container.get_path(True)])
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 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_move_container_after(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.chapter3 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.extract5 = ExtractFactory(container=self.chapter3, db_object=self.tuto)
self.chapter4 = ContainerFactory(parent=self.part2, db_object=self.tuto)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for container (smoothly)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter3.slug,
'container_slug': self.part1.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(1, len(chapter.children))
self.assertTrue(isfile(chapter.children[0].get_path()))
self.assertEqual(self.extract5.slug, chapter.children[0].slug)
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test changing parent for too deep container
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
def get_published_content(self, author, user_staff, nb_part=1, nb_chapter=1, nb_extract=1):
bigtuto = PublishableContentFactory(type="TUTORIAL")
bigtuto.authors.add(author)
UserGalleryFactory(gallery=bigtuto.gallery, user=author, mode="W")
bigtuto.licence = LicenceFactory()
bigtuto.save()
# populate the bigtuto
bigtuto_draft = bigtuto.load_version()
for i in range(nb_part):
part = ContainerFactory(parent=bigtuto_draft, db_object=bigtuto)
for j in range(nb_chapter):
chapter = ContainerFactory(parent=part, db_object=bigtuto)
for k in range(nb_extract):
ExtractFactory(container=chapter, db_object=bigtuto)
# connect with author:
self.client.force_login(author)
# ask validation
self.client.post(
reverse("validation:ask", kwargs={"pk": bigtuto.pk, "slug": bigtuto.slug}),
{"text": "ask for validation", "source": "", "version": bigtuto_draft.current_version},
follow=False,
)
# login with staff and publish
self.client.force_login(user_staff)
validation = Validation.objects.filter(content=bigtuto).last()
self.client.post(
reverse("validation:reserve", kwargs={"pk": validation.pk}), {"version": validation.version}, follow=False
)
# accept
self.client.post(
reverse("validation:accept", kwargs={"pk": validation.pk}),
{"text": "accept validation", "is_major": True, "source": ""},
follow=False,
)
self.client.logout()
published = PublishedContent.objects.filter(content=bigtuto).first()
self.assertIsNotNone(published)
return published
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 handle_content_with_chapter_and_parts(container, current_size, fake, nb_avg_containers_in_content,
nb_avg_extracts_in_content):
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)
def generate_text_for_content(current_size, fake, is_articles, is_opinion, nb_avg_containers_in_content,
nb_avg_extracts_in_content, versioned):
if current_size == 0 or is_articles or is_opinion:
for _ 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 _ in range(random.randint(1, nb_avg_containers_in_content * 2)):
container = ContainerFactory(parent=versioned, title=fake.text(max_nb_chars=60))
handle_content_with_chapter_and_parts(container, current_size, fake, nb_avg_containers_in_content,
nb_avg_extracts_in_content)
def test_tagged_tree_extract(self):
midsize = PublishableContentFactory(author_list=[self.user_author])
midsize_draft = midsize.load_version()
first_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
second_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
first_extract = ExtractFactory(container=first_container, db_object=midsize)
second_extract = ExtractFactory(container=second_container, db_object=midsize)
tagged_tree = get_target_tagged_tree_for_extract(first_extract, midsize_draft)
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(paths[second_extract.get_full_slug()])
self.assertFalse(paths[second_container.get_path(True)])
self.assertFalse(paths[first_container.get_path(True)])
def setUp(self):
self.overridden_zds_app = overridden_zds_app
# don't build PDF to speed up the tests
overridden_zds_app['content']['build_pdf_when_published'] = False
self.staff = StaffProfileFactory().user
settings.EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend'
self.mas = ProfileFactory().user
overridden_zds_app['member']['bot_account'] = self.mas.username
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory()
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
self.content = PublishableContentFactory(author_list=[self.user_author], light=False)
self.part_published = ContainerFactory(db_object=self.content, light=False, parent=self.content.load_version())
self.ignored_part = ContainerFactory(db_object=self.content, light=False, parent=self.content.load_version())
ExtractFactory(db_object=self.content, container=self.part_published, light=False)
ExtractFactory(db_object=self.content, container=self.ignored_part, light=False)
def 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_boosts(self):
"""Check if boosts are doing their job"""
if not self.manager.connected_to_es:
return
# 1. Create topics (with identical titles), posts (with identical texts), an article and a tuto
text = 'test'
topic_1_solved_sticky = TopicFactory(forum=self.forum, author=self.user)
topic_1_solved_sticky.title = text
topic_1_solved_sticky.subtitle = ''
topic_1_solved_sticky.solved_by = self.user
topic_1_solved_sticky.is_sticky = True
topic_1_solved_sticky.save()
post_1 = PostFactory(topic=topic_1_solved_sticky, author=self.user, position=1)
post_1.text = post_1.text_html = text
post_1.save()
post_2_useful = PostFactory(topic=topic_1_solved_sticky, author=self.user, position=2)
post_2_useful.text = post_2_useful.text_html = text
post_2_useful.is_useful = True
post_2_useful.like = 5
post_2_useful.dislike = 2 # l/d ratio above 1
post_2_useful.save()
topic_2_locked = TopicFactory(forum=self.forum, author=self.user, title=text)
topic_2_locked.title = text
topic_2_locked.subtitle = ''
topic_2_locked.is_locked = True
topic_2_locked.save()
post_3_ld_below_1 = PostFactory(topic=topic_2_locked, author=self.user, position=1)
post_3_ld_below_1.text = post_3_ld_below_1.text_html = text
post_3_ld_below_1.like = 2
post_3_ld_below_1.dislike = 5 # l/d ratio below 1
post_3_ld_below_1.save()
tuto = PublishableContentFactory(type='TUTORIAL')
tuto_draft = tuto.load_version()
tuto.title = text
tuto.authors.add(self.user)
tuto.save()
tuto_draft.repo_update_top_container(text, tuto.slug, text, text)
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter1.repo_update(text, 'Who cares ?', 'Same here')
ExtractFactory(container=chapter1, db_object=tuto)
published_tuto = 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
tuto.save()
article = PublishedContentFactory(type='ARTICLE', title=text)
published_article = PublishedContent.objects.get(content_pk=article.pk)
opinion_not_picked = PublishedContentFactory(type='OPINION', title=text)
published_opinion_not_picked = PublishedContent.objects.get(content_pk=opinion_not_picked.pk)
opinion_picked = PublishedContentFactory(type='OPINION', title=text)
opinion_picked.sha_picked = opinion_picked.sha_draft
opinion_picked.date_picked = datetime.datetime.now()
opinion_picked.save()
published_opinion_picked = PublishedContent.objects.get(content_pk=opinion_picked.pk)
for model in self.indexable:
if model is FakeChapter:
continue
self.manager.es_bulk_indexing_of_model(model)
self.manager.refresh_index()
self.assertEqual(len(self.manager.setup_search(Search().query(MatchAll())).execute()), 10)
# 2. Reset all boosts to 1
for doc_type in settings.ZDS_APP['search']['boosts']:
for key in settings.ZDS_APP['search']['boosts'][doc_type]:
settings.ZDS_APP['search']['boosts'][doc_type][key] = 1.0
# 3. Test posts
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Post.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
# score are equals without boost:
self.assertTrue(response[0].meta.score == response[1].meta.score == response[2].meta.score)
settings.ZDS_APP['search']['boosts']['post']['if_first'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Post.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score == response[1].meta.score > response[2].meta.score)
self.assertEqual(response[2].meta.id, str(post_2_useful.pk)) # post 2 is the only one not first
settings.ZDS_APP['search']['boosts']['post']['if_first'] = 1.0
settings.ZDS_APP['search']['boosts']['post']['if_useful'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Post.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score > response[1].meta.score == response[2].meta.score)
self.assertEqual(response[0].meta.id, str(post_2_useful.pk)) # post 2 is useful
settings.ZDS_APP['search']['boosts']['post']['if_useful'] = 1.0
settings.ZDS_APP['search']['boosts']['post']['ld_ratio_above_1'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Post.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score > response[1].meta.score == response[2].meta.score)
self.assertEqual(response[0].meta.id, str(post_2_useful.pk)) # post 2 have a l/d ratio of 5/2
settings.ZDS_APP['search']['boosts']['post']['ld_ratio_above_1'] = 1.0
settings.ZDS_APP['search']['boosts']['post']['ld_ratio_below_1'] = 2.0 # no one would do that in real life
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Post.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score > response[1].meta.score == response[2].meta.score)
self.assertEqual(response[0].meta.id, str(post_3_ld_below_1.pk)) # post 3 have a l/d ratio of 2/5
settings.ZDS_APP['search']['boosts']['post']['ld_ratio_below_1'] = 1.0
# 4. Test topics
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Topic.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
# score are equals without boost:
self.assertTrue(response[0].meta.score == response[1].meta.score)
settings.ZDS_APP['search']['boosts']['topic']['if_sticky'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Topic.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id, str(topic_1_solved_sticky.pk)) # topic 1 is sticky
settings.ZDS_APP['search']['boosts']['topic']['if_sticky'] = 1.0
settings.ZDS_APP['search']['boosts']['topic']['if_solved'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Topic.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id, str(topic_1_solved_sticky.pk)) # topic 1 is solved
settings.ZDS_APP['search']['boosts']['topic']['if_solved'] = 1.0
settings.ZDS_APP['search']['boosts']['topic']['if_locked'] = 2.0 # no one would do that in real life
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=' + Topic.get_es_document_type(), follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id, str(topic_2_locked.pk)) # topic 2 is locked
settings.ZDS_APP['search']['boosts']['topic']['if_locked'] = 1.0 # no one would do that in real life
# 5. Test published contents
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=content', follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
# score are equals without boost:
self.assertTrue(response[0].meta.score ==
response[1].meta.score ==
response[2].meta.score ==
response[3].meta.score ==
response[4].meta.score)
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_article'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=content', follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id, str(published_article.pk)) # obvious
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_article'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_tutorial'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=content', follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id, str(published_tuto.pk)) # obvious
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_tutorial'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_opinion'] = 2.0
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_opinion_not_picked'] = 4.0
# Note: in "real life", unpicked opinion would get a boost < 1.
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=content', follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score > response[2].meta.score)
self.assertEqual(response[0].meta.id, str(published_opinion_not_picked.pk)) # unpicked opinion got first
self.assertEqual(response[1].meta.id, str(published_opinion_picked.pk))
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_opinion'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_opinion_not_picked'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_medium_or_big_tutorial'] = 2.0
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=content', follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id, str(published_tuto.pk)) # obvious
settings.ZDS_APP['search']['boosts']['publishedcontent']['if_medium_or_big_tutorial'] = 1.0
# 6. Test global boosts
# NOTE: score are NOT the same for all documents, no matter how hard it tries to, small differences exists
for model in self.indexable:
# set a huge number to overcome the small differences:
settings.ZDS_APP['search']['boosts'][model.get_es_document_type()]['global'] = 10.0
result = self.client.get(
reverse('search:query') + '?q=' + text, follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 10)
self.assertEqual(response[0].meta.doc_type, model.get_es_document_type()) # obvious
settings.ZDS_APP['search']['boosts'][model.get_es_document_type()]['global'] = 1.0
def test_change_publishedcontents_impacts_chapter(self):
if not self.manager.connected_to_es:
return
# 1. Create middle-size content and index it
text = 'test'
tuto = PublishableContentFactory(type='TUTORIAL')
tuto_draft = tuto.load_version()
tuto.title = text
tuto.authors.add(self.user)
tuto.save()
tuto_draft.repo_update_top_container(text, tuto.slug, text, text) # change title to be sure it will match
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter1.repo_update(text, text, text)
extract = ExtractFactory(container=chapter1, db_object=tuto)
extract.repo_update(text, text)
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()
self.manager.es_bulk_indexing_of_model(PublishedContent)
self.manager.refresh_index()
self.assertEqual(len(self.manager.setup_search(Search().query(MatchAll())).execute()), 2) # indexing ok
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=content', follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
chapters = [r for r in response if r.meta.doc_type == 'chapter']
self.assertEqual(chapters[0].meta.doc_type, FakeChapter.get_es_document_type())
self.assertEqual(chapters[0].meta.id, published.content_public_slug + '__' + chapter1.slug)
# 2. Change tuto: delete chapter and insert new one !
tuto = PublishableContent.objects.get(pk=tuto.pk)
tuto_draft = tuto.load_version()
tuto_draft.children[0].repo_delete() # chapter 1 is gone !
another_text = 'another thing'
self.assertTrue(text not in another_text) # to prevent a future modification from breaking this test
chapter2 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter2.repo_update(another_text, another_text, another_text)
extract2 = ExtractFactory(container=chapter2, db_object=tuto)
extract2.repo_update(another_text, another_text)
published = publish_content(tuto, tuto_draft, is_major_update=False)
tuto.sha_public = tuto_draft.current_version
tuto.sha_draft = tuto_draft.current_version
tuto.public_version = published
tuto.save()
self.manager.es_bulk_indexing_of_model(PublishedContent)
self.manager.refresh_index()
self.assertEqual(len(self.manager.setup_search(Search().query(MatchAll())).execute()), 2) # 2 objects, not 3 !
result = self.client.get(
reverse('search:query') + '?q=' + text + '&models=content', follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
contents = [r for r in response if r.meta.doc_type != 'chapter']
self.assertEqual(response.hits.total, len(contents)) # no chapter found anymore
result = self.client.get(
reverse('search:query') + '?q=' + another_text + '&models=content',
follow=False
)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
chapters = [r for r in response if r.meta.doc_type == 'chapter']
self.assertEqual(response.hits.total, 1)
self.assertEqual(chapters[0].meta.doc_type, FakeChapter.get_es_document_type())
self.assertEqual(chapters[0].meta.id, published.content_public_slug + '__' + chapter2.slug) # got new chapter
def test_upercase_and_lowercase_search_give_same_results(self):
"""Pretty self-explanatory function name, isn't it ?"""
if not self.manager.connected_to_es:
return
# 1. Index lowercase stuffs
text_lc = 'test'
topic_1_lc = TopicFactory(forum=self.forum,
author=self.user,
title=text_lc)
tag_lc = TagFactory(title=text_lc)
topic_1_lc.tags.add(tag_lc)
topic_1_lc.subtitle = text_lc
topic_1_lc.save()
post_1_lc = PostFactory(topic=topic_1_lc, author=self.user, position=1)
post_1_lc.text = post_1_lc.text_html = text_lc
post_1_lc.save()
tuto_lc = PublishableContentFactory(type='TUTORIAL')
tuto_draft_lc = tuto_lc.load_version()
tuto_lc.title = text_lc
tuto_lc.authors.add(self.user)
subcategory_lc = SubCategoryFactory(title=text_lc)
tuto_lc.subcategory.add(subcategory_lc)
tuto_lc.tags.add(tag_lc)
tuto_lc.save()
tuto_draft_lc.description = text_lc
tuto_draft_lc.repo_update_top_container(text_lc, tuto_lc.slug, text_lc,
text_lc)
chapter1_lc = ContainerFactory(parent=tuto_draft_lc, db_object=tuto_lc)
extract_lc = ExtractFactory(container=chapter1_lc, db_object=tuto_lc)
extract_lc.repo_update(text_lc, text_lc)
published_lc = publish_content(tuto_lc,
tuto_draft_lc,
is_major_update=True)
tuto_lc.sha_public = tuto_draft_lc.current_version
tuto_lc.sha_draft = tuto_draft_lc.current_version
tuto_lc.public_version = published_lc
tuto_lc.save()
# 2. Index uppercase stuffs
text_uc = 'TEST'
topic_1_uc = TopicFactory(forum=self.forum,
author=self.user,
title=text_uc)
topic_1_uc.tags.add(
tag_lc) # Note: a constraint forces tags title to be unique
topic_1_uc.subtitle = text_uc
topic_1_uc.save()
post_1_uc = PostFactory(topic=topic_1_uc, author=self.user, position=1)
post_1_uc.text = post_1_uc.text_html = text_uc
post_1_uc.save()
tuto_uc = PublishableContentFactory(type='TUTORIAL')
tuto_draft_uc = tuto_uc.load_version()
tuto_uc.title = text_uc
tuto_uc.authors.add(self.user)
tuto_uc.subcategory.add(subcategory_lc)
tuto_uc.tags.add(tag_lc)
tuto_uc.save()
tuto_draft_uc.description = text_uc
tuto_draft_uc.repo_update_top_container(text_uc, tuto_uc.slug, text_uc,
text_uc)
chapter1_uc = ContainerFactory(parent=tuto_draft_uc, db_object=tuto_uc)
extract_uc = ExtractFactory(container=chapter1_uc, db_object=tuto_uc)
extract_uc.repo_update(text_uc, text_uc)
published_uc = publish_content(tuto_uc,
tuto_draft_uc,
is_major_update=True)
tuto_uc.sha_public = tuto_draft_uc.current_version
tuto_uc.sha_draft = tuto_draft_uc.current_version
tuto_uc.public_version = published_uc
tuto_uc.save()
# 3. Index and search:
self.assertEqual(
len(
self.manager.setup_search(Search().query(
MatchAll())).execute()), 0)
# index
for model in self.indexable:
if model is FakeChapter:
continue
self.manager.es_bulk_indexing_of_model(model)
self.manager.refresh_index()
result = self.client.get(reverse('search:query') + '?q=' + text_lc,
follow=False)
self.assertEqual(result.status_code, 200)
response_lc = result.context['object_list'].execute()
self.assertEqual(response_lc.hits.total, 8)
result = self.client.get(reverse('search:query') + '?q=' + text_uc,
follow=False)
self.assertEqual(result.status_code, 200)
response_uc = result.context['object_list'].execute()
self.assertEqual(response_uc.hits.total, 8)
for responses in zip(
response_lc,
response_uc): # we should get results in the same order!
self.assertEqual(responses[0].meta.id, responses[1].meta.id)
def test_move_extract_before(self):
# test 1 : move extract after a sibling
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
self.extract3 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.extract3.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for extract (smoothly)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.extract4 = ExtractFactory(container=self.chapter2, db_object=self.tuto)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.extract4.get_full_slug(),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test changing parents on a 'midsize content' (i.e depth of 1)
midsize = PublishableContentFactory(author_list=[self.user_author])
midsize_draft = midsize.load_version()
first_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
second_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
first_extract = ExtractFactory(container=first_container, db_object=midsize)
second_extract = ExtractFactory(container=second_container, db_object=midsize)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': first_extract.slug,
'container_slug': first_container.get_path(True),
'first_level_slug': '',
'moving_method': 'before:' + second_extract.get_full_slug(),
'pk': midsize.pk
},
follow=True)
self.assertEqual(result.status_code, 200)
self.assertFalse(isfile(first_extract.get_path(True)))
midsize = PublishableContent.objects.filter(pk=midsize.pk).first()
midsize_draft = midsize.load_version()
second_container_draft = midsize_draft.children[1]
self.assertEqual(second_container_draft.children[0].title, first_extract.title)
self.assertTrue(second_container_draft.children[0].get_path(False))
# test try to move to a container that can't get extract
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.chapter1.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move near an extract that does not exist
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.chapter1.get_path(True) + '/un-mauvais-extrait',
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
def test_basic_search(self):
"""Basic search and filtering"""
if not self.manager.connected_to_es:
return
# 1. Index and test search:
text = 'test'
topic_1 = TopicFactory(forum=self.forum, author=self.user, title=text)
post_1 = PostFactory(topic=topic_1, author=self.user, position=1)
post_1.text = post_1.text_html = text
post_1.save()
# create a middle-size content and publish it
tuto = PublishableContentFactory(type='TUTORIAL')
tuto_draft = tuto.load_version()
tuto.title = text
tuto.authors.add(self.user)
tuto.save()
tuto_draft.repo_update_top_container(
text, tuto.slug, text,
text) # change title to be sure it will match
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto)
extract = ExtractFactory(container=chapter1, db_object=tuto)
extract.repo_update(text, text)
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()
# nothing has been indexed yet:
self.assertEqual(
len(
self.manager.setup_search(Search().query(
MatchAll())).execute()), 0)
# index
for model in self.indexable:
if model is FakeChapter:
continue
self.manager.es_bulk_indexing_of_model(model)
self.manager.refresh_index()
result = self.client.get(reverse('search:query') + '?q=' + text,
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 4) # get 4 results
# 2. Test filtering:
topic_1 = Topic.objects.get(pk=topic_1.pk)
post_1 = Post.objects.get(pk=post_1.pk)
published = PublishedContent.objects.get(pk=published.pk)
ids = {
'topic': [topic_1.es_id],
'post': [post_1.es_id],
'content': [
published.es_id,
published.content_public_slug + '__' + chapter1.slug
],
}
search_groups = [
k for k, v in settings.ZDS_APP['search']['search_groups'].items()
]
group_to_model = {
k: v[1]
for k, v in settings.ZDS_APP['search']['search_groups'].items()
}
for doc_type in search_groups:
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + doc_type,
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total,
len(ids[doc_type])) # get 1 result of each …
for i, r in enumerate(response):
self.assertIn(
r.meta.doc_type,
group_to_model[doc_type]) # … and only of the right type …
self.assertEqual(r.meta.id,
ids[doc_type][i]) # … with the right id !
def test_category_and_subcategory_impact_search(self):
"""If two contents do not belong to the same (sub)category"""
if not self.manager.connected_to_es:
return
text = 'Did you ever hear the tragedy of Darth Plagueis The Wise?'
# 1. Create two contents with different subcategories
category_1 = 'category 1'
subcategory_1 = SubCategoryFactory(title=category_1)
category_2 = 'category 2'
subcategory_2 = SubCategoryFactory(title=category_2)
tuto_1 = PublishableContentFactory(type='TUTORIAL')
tuto_1_draft = tuto_1.load_version()
tuto_1.title = text
tuto_1.authors.add(self.user)
tuto_1.subcategory.add(subcategory_1)
tuto_1.save()
tuto_1_draft.description = text
tuto_1_draft.repo_update_top_container(text, tuto_1.slug, text, text)
chapter_1 = ContainerFactory(parent=tuto_1_draft, db_object=tuto_1)
extract_1 = ExtractFactory(container=chapter_1, db_object=tuto_1)
extract_1.repo_update(text, text)
published_1 = publish_content(tuto_1,
tuto_1_draft,
is_major_update=True)
tuto_1.sha_public = tuto_1_draft.current_version
tuto_1.sha_draft = tuto_1_draft.current_version
tuto_1.public_version = published_1
tuto_1.save()
tuto_2 = PublishableContentFactory(type='TUTORIAL')
tuto_2_draft = tuto_2.load_version()
tuto_2.title = text
tuto_2.authors.add(self.user)
tuto_2.subcategory.add(subcategory_2)
tuto_2.save()
tuto_2_draft.description = text
tuto_2_draft.repo_update_top_container(text, tuto_2.slug, text, text)
chapter_2 = ContainerFactory(parent=tuto_2_draft, db_object=tuto_2)
extract_2 = ExtractFactory(container=chapter_2, db_object=tuto_2)
extract_2.repo_update(text, text)
published_2 = publish_content(tuto_2,
tuto_2_draft,
is_major_update=True)
tuto_2.sha_public = tuto_2_draft.current_version
tuto_2.sha_draft = tuto_2_draft.current_version
tuto_2.public_version = published_2
tuto_2.save()
# 2. Index:
self.assertEqual(
len(
self.manager.setup_search(Search().query(
MatchAll())).execute()), 0)
# index
for model in self.indexable:
if model is FakeChapter:
continue
self.manager.es_bulk_indexing_of_model(model)
self.manager.refresh_index()
result = self.client.get(reverse('search:query') + '?q=' + text,
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 4) # Ok
# 3. Test
result = self.client.get(reverse('search:query') + '?q=' + text +
'&model=content&subcategory=' +
subcategory_1.slug,
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertEqual([
int(r.meta.id) for r in response
if r.meta.doc_type == 'publishedcontent'
][0], published_1.pk)
self.assertEqual([
r.meta.id for r in response if r.meta.doc_type == 'chapter'
][0], tuto_1.slug + '__' + chapter_1.slug)
result = self.client.get(reverse('search:query') + '?q=' + text +
'&model=content&subcategory=' +
subcategory_2.slug,
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertEqual([
int(r.meta.id) for r in response
if r.meta.doc_type == 'publishedcontent'
][0], published_2.pk)
self.assertEqual([
r.meta.id for r in response if r.meta.doc_type == 'chapter'
][0], tuto_2.slug + '__' + chapter_2.slug)
def test_indexation(self):
"""test the indexation and deletion of the different documents"""
if not self.manager.connected_to_es:
return
# create a topic with a post
topic = TopicFactory(forum=self.forum, author=self.user)
post = PostFactory(topic=topic, author=self.user, position=1)
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)
ExtractFactory(container=chapter1, db_object=tuto)
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.get(content_pk=tuto.pk)
self.assertFalse(published.es_already_indexed)
self.assertTrue(published.es_flagged)
# 1. index all
for model in self.indexable:
if model is FakeChapter:
continue
self.manager.es_bulk_indexing_of_model(model, force_reindexing=False)
self.manager.refresh_index()
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.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 what reindexation will do:
new_topic = TopicFactory(forum=self.forum, author=self.user)
new_post = PostFactory(topic=new_topic, author=self.user, position=1)
pk_of_topics_to_reindex = []
for item in Topic.get_es_indexable(force_reindexing=False):
pk_of_topics_to_reindex.append(item.pk)
pk_of_posts_to_reindex = []
for item in Post.get_es_indexable(force_reindexing=False):
pk_of_posts_to_reindex.append(item.pk)
self.assertTrue(topic.pk not in pk_of_topics_to_reindex)
self.assertTrue(new_topic.pk in pk_of_topics_to_reindex)
self.assertTrue(post.pk not in pk_of_posts_to_reindex)
self.assertTrue(new_post.pk in pk_of_posts_to_reindex)
for model in self.indexable: # ok, so let's index that
if model is FakeChapter:
continue
self.manager.es_bulk_indexing_of_model(model, force_reindexing=False)
self.manager.refresh_index()
s = Search()
s.query(MatchAll())
results = self.manager.setup_search(s).execute()
self.assertEqual(len(results), 6) # good!
# 3. Test single deletion:
new_post = Post.objects.get(pk=new_post.pk)
self.manager.delete_document(new_post)
self.manager.refresh_index()
s = Search()
s.query(MatchAll())
results = self.manager.setup_search(s).execute()
self.assertEqual(len(results), 5) # one is missing
for hit in results:
self.assertTrue(hit.meta.doc_type != Post.get_es_document_type() or hit.meta.id != new_post.es_id)
# 4. Test "delete_by_query_deletion":
topic = Topic.objects.get(pk=topic.pk)
new_topic = Topic.objects.get(pk=new_topic.pk)
self.manager.delete_by_query(Topic.get_es_document_type(), MatchAll()) # the two topic are deleted
self.manager.refresh_index()
s = Search()
s.query(MatchAll())
results = self.manager.setup_search(s).execute()
self.assertEqual(len(results), 3)
for hit in results:
self.assertTrue(hit.meta.doc_type != Topic.get_es_document_type() or hit.meta.id != new_topic.es_id)
self.assertTrue(hit.meta.doc_type != Topic.get_es_document_type() or hit.meta.id != topic.es_id)
# 5. Test that the deletion of an object also triggers its deletion in ES
post = Post.objects.get(pk=post.pk)
post.delete()
self.manager.refresh_index()
s = Search()
s.query(MatchAll())
results = self.manager.setup_search(s).execute()
self.assertEqual(len(results), 2)
for hit in results:
self.assertTrue(hit.meta.doc_type != Post.get_es_document_type() or hit.meta.id != post.es_id)
# 6. Test full desindexation:
for model in self.indexable:
if model is FakeChapter:
continue
self.manager.clear_indexing_of_model(model)
# note "topic" is gone since "post" is gone, due to relationships at the Django level
new_topic = Topic.objects.get(pk=new_topic.pk)
new_post = Post.objects.get(pk=new_post.pk)
self.assertFalse(new_topic.es_already_indexed)
self.assertTrue(new_topic.es_flagged)
self.assertFalse(new_post.es_already_indexed)
self.assertTrue(new_post.es_flagged)
published = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertFalse(published.es_already_indexed)
self.assertTrue(published.es_flagged)
class UtilsTests(TestCase):
def setUp(self):
# don't build PDF to speed up the tests
settings.ZDS_APP['content']['build_pdf_when_published'] = False
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.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type='TUTORIAL')
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery, user=self.user_author, mode='W')
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.old_registry = {key: value for key, value in PublicatorRegistery.get_all_registered()}
def test_get_target_tagged_tree_for_container(self):
part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title="part2")
part3 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title="part3")
tagged_tree = get_target_tagged_tree_for_container(self.part1, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertFalse(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertFalse(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], "can be moved after or before part2")
self.assertTrue(paths[part3.get_path(True)], "can be moved after or before part3")
tagged_tree = get_target_tagged_tree_for_container(part3, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertTrue(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertTrue(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], "can be moved after or before part2")
self.assertFalse(paths[part3.get_path(True)], "can be moved after or before part3")
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_tagged_tree_extract(self):
midsize = PublishableContentFactory(author_list=[self.user_author])
midsize_draft = midsize.load_version()
first_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
second_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
first_extract = ExtractFactory(container=first_container, db_object=midsize)
second_extract = ExtractFactory(container=second_container, db_object=midsize)
tagged_tree = get_target_tagged_tree_for_extract(first_extract, midsize_draft)
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(paths[second_extract.get_full_slug()])
self.assertFalse(paths[second_container.get_path(True)])
self.assertFalse(paths[first_container.get_path(True)])
def test_update_manifest(self):
opts = {}
shutil.copy(
os.path.join(BASE_DIR, "fixtures", "tuto", "balise_audio", "manifest.json"),
os.path.join(BASE_DIR, "fixtures", "tuto", "balise_audio", "manifest2.json")
)
LicenceFactory(code="CC BY")
args = [os.path.join(BASE_DIR, "fixtures", "tuto", "balise_audio", "manifest2.json")]
call_command('upgrade_manifest_to_v2', *args, **opts)
manifest = open(os.path.join(BASE_DIR, "fixtures", "tuto", "balise_audio", "manifest2.json"), 'r')
json = json_reader.loads(manifest.read())
self.assertTrue(u"version" in json)
self.assertTrue(u"licence" in json)
self.assertTrue(u"children" in json)
self.assertEqual(len(json[u"children"]), 3)
self.assertEqual(json[u"children"][0][u"object"], u"extract")
os.unlink(args[0])
args = [os.path.join(BASE_DIR, "fixtures", "tuto", "big_tuto_v1", "manifest2.json")]
shutil.copy(
os.path.join(BASE_DIR, "fixtures", "tuto", "big_tuto_v1", "manifest.json"),
os.path.join(BASE_DIR, "fixtures", "tuto", "big_tuto_v1", "manifest2.json")
)
call_command('upgrade_manifest_to_v2', *args, **opts)
manifest = open(os.path.join(BASE_DIR, "fixtures", "tuto", "big_tuto_v1", "manifest2.json"), 'r')
json = json_reader.loads(manifest.read())
os.unlink(args[0])
self.assertTrue(u"version" in json)
self.assertTrue(u"licence" in json)
self.assertTrue(u"children" in json)
self.assertEqual(len(json[u"children"]), 5)
self.assertEqual(json[u"children"][0][u"object"], u"container")
self.assertEqual(len(json[u"children"][0][u"children"]), 3)
self.assertEqual(len(json[u"children"][0][u"children"][0][u"children"]), 3)
args = [os.path.join(BASE_DIR, "fixtures", "tuto", "article_v1", "manifest2.json")]
shutil.copy(
os.path.join(BASE_DIR, "fixtures", "tuto", "article_v1", "manifest.json"),
os.path.join(BASE_DIR, "fixtures", "tuto", "article_v1", "manifest2.json")
)
call_command('upgrade_manifest_to_v2', *args, **opts)
manifest = open(os.path.join(BASE_DIR, "fixtures", "tuto", "article_v1", "manifest2.json"), 'r')
json = json_reader.loads(manifest.read())
self.assertTrue(u"version" in json)
self.assertTrue(u"licence" in json)
self.assertTrue(u"children" in json)
self.assertEqual(len(json[u"children"]), 1)
os.unlink(args[0])
def test_retrieve_images(self):
"""test the ``retrieve_and_update_images_links()`` function.
NOTE: this test require an working internet connection to succeed
Also, it was implemented with small images on highly responsive server(s), to make it quick !
"""
tempdir = os.path.join(tempfile.gettempdir(), 'test_retrieve_imgs')
os.makedirs(tempdir)
# image which exists, or not
test_images = [
# PNG:
('http://upload.wikimedia.org/wikipedia/en/9/9d/Commons-logo-31px.png', 'Commons-logo-31px.png'),
# JPEG:
('http://upload.wikimedia.org/wikipedia/commons/6/6b/01Aso.jpg', '01Aso.jpg'),
# Image which does not exists:
('http://test.com/test idiot.png', 'test_idiot.png'), # NOTE: space changed into `_` !
# SVG (will be converted to png):
('http://upload.wikimedia.org/wikipedia/commons/f/f9/10DF.svg', '10DF.png'),
# GIF (will be converted to png):
('http://upload.wikimedia.org/wikipedia/commons/2/27/AnimatedStar.gif', 'AnimatedStar.png'),
# local image:
('fixtures/image_test.jpg', 'image_test.jpg')
]
# for each of these images, test that the url (and only that) is changed
for url, filename in test_images:
random_thing = str(datetime.datetime.now()) # will be used as legend, to ensure that this part remains
an_image_link = ''.format(random_thing, url)
new_image_url = 'images/{}'.format(filename)
new_image_link = ''.format(random_thing, new_image_url)
new_md = retrieve_and_update_images_links(an_image_link, tempdir)
self.assertTrue(os.path.isfile(os.path.join(tempdir, new_image_url))) # image was retrieved
self.assertEqual(new_image_link, new_md) # link was updated
# then, ensure that 3 times the same images link make the code use three times the same image !
link = ''
new_link = ''
three_times = ' '.join([link.format(i) for i in range(0, 2)])
three_times_updated = ' '.join([new_link.format(i) for i in range(0, 2)])
new_md = retrieve_and_update_images_links(three_times, tempdir)
self.assertEqual(three_times_updated, new_md)
# ensure that the original file is deleted if any
another_svg = ''
new_md = retrieve_and_update_images_links(another_svg, tempdir)
self.assertEqual('', new_md)
self.assertTrue(os.path.isfile(os.path.join(tempdir, 'images/Arrow.png'))) # image was converted in PNG
self.assertFalse(os.path.isfile(os.path.join(tempdir, 'images/Arrow.svg'))) # and the original SVG was deleted
# finally, clean up:
shutil.rmtree(tempdir)
def test_generate_pdf(self):
"""ensure the behavior of the `python manage.py generate_pdf` commmand"""
settings.ZDS_APP['content']['build_pdf_when_published'] = True # this test need PDF build, if any
tuto = PublishedContentFactory(type='TUTORIAL') # generate and publish a tutorial
published = PublishedContent.objects.get(content_pk=tuto.pk)
tuto2 = PublishedContentFactory(type='TUTORIAL') # generate and publish a second tutorial
published2 = PublishedContent.objects.get(content_pk=tuto2.pk)
# ensure that PDF exists in the first place
self.assertTrue(published.have_pdf())
self.assertTrue(published2.have_pdf())
pdf_path = os.path.join(published.get_extra_contents_directory(), published.content_public_slug + '.pdf')
pdf_path2 = os.path.join(published2.get_extra_contents_directory(), published2.content_public_slug + '.pdf')
self.assertTrue(os.path.exists(pdf_path))
self.assertTrue(os.path.exists(pdf_path2))
# 1. re-generate (all) PDFs
os.remove(pdf_path)
os.remove(pdf_path2)
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2))
call_command('generate_pdf')
self.assertTrue(os.path.exists(pdf_path))
self.assertTrue(os.path.exists(pdf_path2)) # both PDFs are generated
# 2. re-generate a given PDF
os.remove(pdf_path)
os.remove(pdf_path2)
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2))
call_command('generate_pdf', 'id={}'.format(tuto.pk))
self.assertTrue(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2)) # only the first PDF is generated
# 3. re-generate a given PDF with a wrong id
os.remove(pdf_path)
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2))
call_command('generate_pdf', 'id=-1') # There is no content with pk=-1
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2)) # so no PDF is generated !
def test_last_participation_is_old(self):
article = PublishedContentFactory(author_list=[self.user_author], type="ARTICLE")
newUser = ProfileFactory().user
reac = ContentReaction(author=self.user_author, position=1, related_content=article)
reac.update_content("I will find you. And I Will Kill you.")
reac.save()
article.last_note = reac
article.save()
self.assertFalse(last_participation_is_old(article, newUser))
ContentRead(user=self.user_author, note=reac, content=article).save()
reac = ContentReaction(author=newUser, position=2, related_content=article)
reac.update_content("I will find you. And I Will Kill you.")
reac.save()
article.last_note = reac
article.save()
ContentRead(user=newUser, note=reac, content=article).save()
self.assertFalse(last_participation_is_old(article, newUser))
self.assertTrue(last_participation_is_old(article, self.user_author))
def testParseBadManifest(self):
base_content = PublishableContentFactory(author_list=[self.user_author])
versioned = base_content.load_version()
versioned.add_container(Container(u"un peu plus près de 42"))
versioned.dump_json()
manifest = os.path.join(versioned.get_path(), "manifest.json")
dictionary = json_reader.load(open(manifest))
old_title = dictionary['title']
# first bad title
dictionary['title'] = 81 * ['a']
self.assertRaises(BadManifestError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['title'] = "".join(dictionary['title'])
self.assertRaises(BadManifestError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['title'] = '...'
self.assertRaises(InvalidSlugError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['title'] = old_title
dictionary['children'][0]['title'] = 81 * ['a']
self.assertRaises(BadManifestError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['children'][0]['title'] = "bla"
dictionary['children'][0]['slug'] = "..."
self.assertRaises(InvalidSlugError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
def test_get_commit_author(self):
"""Ensure the behavior of `get_commit_author()` :
- `git.Actor` use the pk of the bot account when no one is connected
- `git.Actor` use the pk (and the email) of the connected account when available
(Implementation of `git.Actor` is there :
https://github.com/gitpython-developers/GitPython/blob/master/git/util.py#L312)
"""
# 1. With user connected
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
# go to whatever page, if not, `get_current_user()` does not work at all
result = self.client.get(reverse('zds.pages.views.index'))
self.assertEqual(result.status_code, 200)
actor = get_commit_author()
self.assertEqual(actor['committer'].name, str(self.user_author.pk))
self.assertEqual(actor['author'].name, str(self.user_author.pk))
self.assertEqual(actor['committer'].email, self.user_author.email)
self.assertEqual(actor['author'].email, self.user_author.email)
# 2. Without connected user
self.client.logout()
# as above ...
result = self.client.get(reverse('zds.pages.views.index'))
self.assertEqual(result.status_code, 200)
actor = get_commit_author()
self.assertEqual(actor['committer'].name, str(self.mas.pk))
self.assertEqual(actor['author'].name, str(self.mas.pk))
def invalid_slug_is_invalid(self):
"""ensure that an exception is raised when it should"""
# exception are raised when title are invalid
invalid_titles = [u'-', u'_', u'__', u'-_-', u'$', u'@', u'&', u'{}', u' ', u'...']
for t in invalid_titles:
self.assertRaises(InvalidSlugError, slugify_raise_on_invalid, t)
# Those slugs are recognized as wrong slug
invalid_slugs = [
u'', # empty
u'----', # empty
u'___', # empty
u'-_-', # empty (!)
u'&;', # invalid characters
u'!{', # invalid characters
u'@', # invalid character
u'a ' # space !
]
for s in invalid_slugs:
self.assertFalse(check_slug(s))
# too long slugs are forbidden :
too_damn_long_slug = 'a' * (settings.ZDS_APP['content']['maximum_slug_size'] + 1)
self.assertFalse(check_slug(too_damn_long_slug))
def test_watchdog(self):
PublicatorRegistery.unregister("pdf")
PublicatorRegistery.unregister("epub")
PublicatorRegistery.unregister("html")
with open("path", "w") as f:
f.write("my_content;/path/to/markdown.md")
@PublicatorRegistery.register("test", "", "")
class TestPublicator(Publicator):
def __init__(self, *__):
pass
PublicatorRegistery.get("test").publish = Mock()
event = FileCreatedEvent("path")
handler = TutorialIsPublished()
handler.prepare_generation = Mock()
handler.finish_generation = Mock()
handler.on_created(event)
self.assertTrue(PublicatorRegistery.get("test").publish.called)
handler.finish_generation.assert_called_with("/path/to", "path")
handler.prepare_generation.assert_called_with("/path/to")
def tearDown(self):
if os.path.isdir(settings.ZDS_APP['content']['repo_private_path']):
shutil.rmtree(settings.ZDS_APP['content']['repo_private_path'])
if os.path.isdir(settings.ZDS_APP['content']['repo_public_path']):
shutil.rmtree(settings.ZDS_APP['content']['repo_public_path'])
if os.path.isdir(settings.MEDIA_ROOT):
shutil.rmtree(settings.MEDIA_ROOT)
if os.path.isdir(settings.ZDS_APP['content']['extra_content_watchdog_dir']):
shutil.rmtree(settings.ZDS_APP['content']['extra_content_watchdog_dir'])
# re-active PDF build
settings.ZDS_APP['content']['build_pdf_when_published'] = True
PublicatorRegistery.registry = self.old_registry
class UtilsTests(TutorialTestMixin, TestCase):
def setUp(self):
self.mas = ProfileFactory().user
self.overridden_zds_app['member']['bot_account'] = self.mas.username
self.licence = LicenceFactory()
self.user_author = ProfileFactory().user
self.staff = StaffProfileFactory().user
self.tuto = PublishableContentFactory(type='TUTORIAL')
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery, user=self.user_author, mode='W')
self.tuto.licence = self.licence
self.tuto.save()
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.old_registry = {key: value for key, value in PublicatorRegistry.get_all_registered()}
class TestPdfPublicator(Publicator):
def publish(self, md_file_path, base_name, **kwargs):
with Path(base_name + '.pdf').open('w') as f:
f.write('bla')
shutil.copy2(str(Path(base_name + '.pdf')),
str(Path(md_file_path.replace('__building', '')).parent))
PublicatorRegistry.registry['pdf'] = TestPdfPublicator()
def test_get_target_tagged_tree_for_container(self):
part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title='part2')
part3 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title='part3')
tagged_tree = get_target_tagged_tree_for_container(self.part1, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertFalse(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertFalse(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], 'can be moved after or before part2')
self.assertTrue(paths[part3.get_path(True)], 'can be moved after or before part3')
tagged_tree = get_target_tagged_tree_for_container(part3, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertTrue(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertTrue(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], 'can be moved after or before part2')
self.assertFalse(paths[part3.get_path(True)], 'can be moved after or before part3')
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
# ... For the next tests, I will assume that the unpublication works.
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_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_tagged_tree_extract(self):
midsize = PublishableContentFactory(author_list=[self.user_author])
midsize_draft = midsize.load_version()
first_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
second_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
first_extract = ExtractFactory(container=first_container, db_object=midsize)
second_extract = ExtractFactory(container=second_container, db_object=midsize)
tagged_tree = get_target_tagged_tree_for_extract(first_extract, midsize_draft)
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(paths[second_extract.get_full_slug()])
self.assertFalse(paths[second_container.get_path(True)])
self.assertFalse(paths[first_container.get_path(True)])
def test_update_manifest(self):
opts = {}
shutil.copy(
os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'balise_audio', 'manifest.json'),
os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'balise_audio', 'manifest2.json')
)
LicenceFactory(code='CC BY')
args = [os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'balise_audio', 'manifest2.json')]
call_command('upgrade_manifest_to_v2', *args, **opts)
manifest = open(os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'balise_audio', 'manifest2.json'), 'r')
json = json_handler.loads(manifest.read())
self.assertTrue('version' in json)
self.assertTrue('licence' in json)
self.assertTrue('children' in json)
self.assertEqual(len(json['children']), 3)
self.assertEqual(json['children'][0]['object'], 'extract')
os.unlink(args[0])
args = [os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'big_tuto_v1', 'manifest2.json')]
shutil.copy(
os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'big_tuto_v1', 'manifest.json'),
os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'big_tuto_v1', 'manifest2.json')
)
call_command('upgrade_manifest_to_v2', *args, **opts)
manifest = open(os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'big_tuto_v1', 'manifest2.json'), 'r')
json = json_handler.loads(manifest.read())
os.unlink(args[0])
self.assertTrue('version' in json)
self.assertTrue('licence' in json)
self.assertTrue('children' in json)
self.assertEqual(len(json['children']), 5)
self.assertEqual(json['children'][0]['object'], 'container')
self.assertEqual(len(json['children'][0]['children']), 3)
self.assertEqual(len(json['children'][0]['children'][0]['children']), 3)
args = [os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'article_v1', 'manifest2.json')]
shutil.copy(
os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'article_v1', 'manifest.json'),
os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'article_v1', 'manifest2.json')
)
call_command('upgrade_manifest_to_v2', *args, **opts)
manifest = open(os.path.join(settings.BASE_DIR, 'fixtures', 'tuto', 'article_v1', 'manifest2.json'), 'r')
json = json_handler.loads(manifest.read())
self.assertTrue('version' in json)
self.assertTrue('licence' in json)
self.assertTrue('children' in json)
self.assertEqual(len(json['children']), 1)
os.unlink(args[0])
def test_generate_markdown(self):
tuto = PublishedContentFactory(type='TUTORIAL') # generate and publish a tutorial
published = PublishedContent.objects.get(content_pk=tuto.pk)
tuto2 = PublishedContentFactory(type='TUTORIAL') # generate and publish a second tutorial
published2 = PublishedContent.objects.get(content_pk=tuto2.pk)
self.assertTrue(published.has_md())
self.assertTrue(published2.has_md())
os.remove(str(Path(published.get_extra_contents_directory(), published.content_public_slug + '.md')))
os.remove(str(Path(published2.get_extra_contents_directory(), published2.content_public_slug + '.md')))
self.assertFalse(published.has_md())
self.assertFalse(published2.has_md())
# test command with param
call_command('generate_markdown', published.content.pk)
self.assertTrue(published.has_md())
self.assertFalse(published2.has_md())
os.remove(str(Path(published.get_extra_contents_directory(), published.content_public_slug + '.md')))
# test command without param
call_command('generate_markdown')
self.assertTrue(published.has_md())
self.assertTrue(published2.has_md())
def test_generate_pdf(self):
"""ensure the behavior of the `python manage.py generate_pdf` commmand"""
self.overridden_zds_app['content']['build_pdf_when_published'] = True # this test need PDF build, if any
tuto = PublishedContentFactory(type='TUTORIAL') # generate and publish a tutorial
published = PublishedContent.objects.get(content_pk=tuto.pk)
tuto2 = PublishedContentFactory(type='TUTORIAL') # generate and publish a second tutorial
published2 = PublishedContent.objects.get(content_pk=tuto2.pk)
# ensure that PDF exists in the first place
self.assertTrue(published.has_pdf())
self.assertTrue(published2.has_pdf())
pdf_path = os.path.join(published.get_extra_contents_directory(), published.content_public_slug + '.pdf')
pdf_path2 = os.path.join(published2.get_extra_contents_directory(), published2.content_public_slug + '.pdf')
self.assertTrue(os.path.exists(pdf_path))
self.assertTrue(os.path.exists(pdf_path2))
# 1. re-generate (all) PDFs
os.remove(pdf_path)
os.remove(pdf_path2)
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2))
call_command('generate_pdf')
self.assertTrue(os.path.exists(pdf_path))
self.assertTrue(os.path.exists(pdf_path2)) # both PDFs are generated
# 2. re-generate a given PDF
os.remove(pdf_path)
os.remove(pdf_path2)
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2))
call_command('generate_pdf', 'id={}'.format(tuto.pk))
self.assertTrue(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2)) # only the first PDF is generated
# 3. re-generate a given PDF with a wrong id
os.remove(pdf_path)
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2))
call_command('generate_pdf', 'id=-1') # There is no content with pk=-1
self.assertFalse(os.path.exists(pdf_path))
self.assertFalse(os.path.exists(pdf_path2)) # so no PDF is generated !
def test_last_participation_is_old(self):
article = PublishedContentFactory(author_list=[self.user_author], type='ARTICLE')
new_user = ProfileFactory().user
reac = ContentReaction(author=self.user_author, position=1, related_content=article)
reac.update_content('I will find you.')
reac.save()
article.last_note = reac
article.save()
self.assertFalse(last_participation_is_old(article, new_user))
ContentRead(user=self.user_author, note=reac, content=article).save()
reac = ContentReaction(author=new_user, position=2, related_content=article)
reac.update_content('I will find you.')
reac.save()
article.last_note = reac
article.save()
ContentRead(user=new_user, note=reac, content=article).save()
self.assertFalse(last_participation_is_old(article, new_user))
self.assertTrue(last_participation_is_old(article, self.user_author))
def testParseBadManifest(self):
base_content = PublishableContentFactory(author_list=[self.user_author])
versioned = base_content.load_version()
versioned.add_container(Container('un peu plus près de 42'))
versioned.dump_json()
manifest = os.path.join(versioned.get_path(), 'manifest.json')
dictionary = json_handler.load(open(manifest))
old_title = dictionary['title']
# first bad title
dictionary['title'] = 81 * ['a']
self.assertRaises(BadManifestError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['title'] = ''.join(dictionary['title'])
self.assertRaises(BadManifestError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['title'] = '...'
self.assertRaises(InvalidSlugError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['title'] = old_title
dictionary['children'][0]['title'] = 81 * ['a']
self.assertRaises(BadManifestError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
dictionary['children'][0]['title'] = 'bla'
dictionary['children'][0]['slug'] = '...'
self.assertRaises(InvalidSlugError,
get_content_from_json, dictionary, None, '',
max_title_len=PublishableContent._meta.get_field('title').max_length)
def test_get_commit_author(self):
"""Ensure the behavior of `get_commit_author()` :
- `git.Actor` use the pk of the bot account when no one is connected
- `git.Actor` use the pk (and the email) of the connected account when available
(Implementation of `git.Actor` is there :
https://github.com/gitpython-developers/GitPython/blob/master/git/util.py#L312)
"""
# 1. With user connected
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
# go to whatever page, if not, `get_current_user()` does not work at all
result = self.client.get(reverse('pages-index'))
self.assertEqual(result.status_code, 200)
actor = get_commit_author()
self.assertEqual(actor['committer'].name, str(self.user_author.pk))
self.assertEqual(actor['author'].name, str(self.user_author.pk))
self.assertEqual(actor['committer'].email, self.user_author.email)
self.assertEqual(actor['author'].email, self.user_author.email)
def test_get_commit_author_not_auth(self):
result = self.client.get(reverse('pages-index'))
self.assertEqual(result.status_code, 200)
actor = get_commit_author()
self.assertEqual(actor['committer'].name, str(self.mas.pk))
self.assertEqual(actor['author'].name, str(self.mas.pk))
def invalid_slug_is_invalid(self):
"""ensure that an exception is raised when it should"""
# exception are raised when title are invalid
invalid_titles = ['-', '_', '__', '-_-', '$', '@', '&', '{}', ' ', '...']
for t in invalid_titles:
self.assertRaises(InvalidSlugError, slugify_raise_on_invalid, t)
# Those slugs are recognized as wrong slug
invalid_slugs = [
'', # empty
'----', # empty
'___', # empty
'-_-', # empty (!)
'&;', # invalid characters
'!{', # invalid characters
'@', # invalid character
'a ' # space !
]
for s in invalid_slugs:
self.assertFalse(check_slug(s))
# too long slugs are forbidden :
too_damn_long_slug = 'a' * (self.overridden_zds_app['content']['maximum_slug_size'] + 1)
self.assertFalse(check_slug(too_damn_long_slug))
def test_watchdog(self):
PublicatorRegistry.unregister('pdf')
PublicatorRegistry.unregister('printable-pdf')
PublicatorRegistry.unregister('epub')
PublicatorRegistry.unregister('html')
with open('path', 'w') as f:
f.write('my_content;/path/to/markdown.md')
@PublicatorRegistry.register('test', '', '')
class TestPublicator(Publicator):
def __init__(self, *__):
pass
PublicatorRegistry.get('test').publish = Mock()
event = FileCreatedEvent('path')
handler = TutorialIsPublished()
handler.prepare_generation = Mock()
handler.finish_generation = Mock()
handler.on_created(event)
self.assertTrue(PublicatorRegistry.get('test').publish.called)
handler.finish_generation.assert_called_with('/path/to', 'path')
handler.prepare_generation.assert_called_with('/path/to')
os.remove('path')
def test_adjust_char_count(self):
"""Test the `adjust_char_count` command"""
article = PublishedContentFactory(type='ARTICLE', author_list=[self.user_author])
published = PublishedContent.objects.filter(content=article).first()
published.char_count = None
published.save()
call_command('adjust_char_count')
published = PublishedContent.objects.get(pk=published.pk)
self.assertEqual(published.char_count, published.get_char_count())
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_no_alert_on_unpublish(self):
"""related to #4860"""
published = PublishedContentFactory(type='OPINION', author_list=[self.user_author])
reaction = ContentReactionFactory(related_content=published, author=ProfileFactory().user, position=1,
pubdate=datetime.datetime.now())
Alert.objects.create(scope='CONTENT', comment=reaction, text='a text', author=ProfileFactory().user,
pubdate=datetime.datetime.now(), content=published)
staff = StaffProfileFactory().user
self.assertEqual(1, get_header_notifications(staff)['alerts']['total'])
unpublish_content(published, staff)
self.assertEqual(0, get_header_notifications(staff)['alerts']['total'])
def tearDown(self):
super().tearDown()
PublicatorRegistry.registry = self.old_registry
def test_get_target_tagged_tree_for_container(self):
part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title="part2")
part3 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto, title="part3")
tagged_tree = get_target_tagged_tree_for_container(self.part1, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertFalse(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertFalse(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], "can be moved after or before part2")
self.assertTrue(paths[part3.get_path(True)], "can be moved after or before part3")
tagged_tree = get_target_tagged_tree_for_container(part3, self.tuto_draft)
self.assertEqual(4, len(tagged_tree))
paths = {i[0]: i[3] for i in tagged_tree}
self.assertTrue(part2.get_path(True) in paths)
self.assertTrue(part3.get_path(True) in paths)
self.assertTrue(self.chapter1.get_path(True) in paths)
self.assertTrue(self.part1.get_path(True) in paths)
self.assertFalse(self.tuto_draft.get_path(True) in paths)
self.assertTrue(paths[self.chapter1.get_path(True)], "can't be moved to a too deep container")
self.assertTrue(paths[self.part1.get_path(True)], "can't be moved after or before himself")
self.assertTrue(paths[part2.get_path(True)], "can be moved after or before part2")
self.assertFalse(paths[part3.get_path(True)], "can be moved after or before part3")
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_special_case_of_contents(self):
"""test that the old publishedcontent does not stay when a new one is created"""
if not self.manager.connected_to_es:
return
# 1. Create a middle-tutorial, publish it, then index 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)
ExtractFactory(container=chapter1, db_object=tuto)
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()
self.manager.es_bulk_indexing_of_model(PublishedContent, force_reindexing=True) # index
self.manager.refresh_index()
first_publication = PublishedContent.objects.get(content_pk=tuto.pk)
self.assertTrue(first_publication.es_already_indexed)
self.assertFalse(first_publication.es_flagged)
s = Search()
s.query(MatchAll())
results = self.manager.setup_search(s).execute()
self.assertEqual(len(results), 2) # get 2 results, one for the content and one for the chapter
self.assertEqual(PublishedContent.objects.count(), 1)
# 2. Change thet title, which will trigger a change in the slug
tuto = PublishableContent.objects.get(pk=tuto.pk)
versioned = tuto.load_version(sha=tuto.sha_draft)
tuto.title = 'un titre complètement différent!'
tuto.save()
versioned.repo_update_top_container(tuto.title, tuto.slug, 'osef', 'osef')
second_publication = publish_content(tuto, versioned, True)
tuto.sha_public = versioned.current_version
tuto.sha_draft = versioned.current_version
tuto.public_version = second_publication
tuto.save()
self.assertEqual(PublishedContent.objects.count(), 2) # now there is two objects ...
first_publication = PublishedContent.objects.get(pk=first_publication.pk)
self.assertTrue(first_publication.must_redirect) # .. including the first one, for redirection
self.manager.refresh_index()
s = Search()
s.query(MatchAll())
results = self.manager.setup_search(s).execute()
self.assertEqual(len(results), 0) # the old one is gone (and we need to reindex to get the new one)
# 3. Check if indexation brings the new one, and not the old one
self.manager.es_bulk_indexing_of_model(PublishedContent, force_reindexing=True) # index
self.manager.refresh_index()
first_publication = PublishedContent.objects.get(pk=first_publication.pk)
second_publication = PublishedContent.objects.get(pk=second_publication.pk)
s = Search()
s.query(MatchAll())
results = self.manager.setup_search(s).execute()
self.assertEqual(len(results), 2) # Still 2, not 4 !
found_old = False
found_new = False
for hit in results:
if hit.meta.doc_type == PublishedContent.get_es_document_type():
if hit.meta.id == first_publication.es_id:
found_old = True
if hit.meta.id == second_publication.es_id:
found_new = True
self.assertTrue(found_new)
self.assertFalse(found_old)
class ContentMoveTests(TestCase):
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()
def test_move_up_extract(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving up smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
# test moving up the first element
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug]\
.children_dict[self.chapter1.slug].children_dict[self.extract2.slug]
self.assertEqual(1, extract.position_in_parent)
# test moving without permission
self.client.logout()
self.assertEqual(
self.client.login(
username=self.user_guest.username,
password='******'),
True)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=False)
self.assertEqual(result.status_code, 403)
def test_move_extract_before(self):
# test 1 : move extract after a sibling
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
self.extract3 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.extract3.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for extract (smoothly)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.extract4 = ExtractFactory(container=self.chapter2, db_object=self.tuto)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.extract4.get_full_slug(),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test changing parents on a 'midsize content' (i.e depth of 1)
midsize = PublishableContentFactory(author_list=[self.user_author])
midsize_draft = midsize.load_version()
first_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
second_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
first_extract = ExtractFactory(container=first_container, db_object=midsize)
second_extract = ExtractFactory(container=second_container, db_object=midsize)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': first_extract.slug,
'container_slug': first_container.get_path(True),
'first_level_slug': '',
'moving_method': 'before:' + second_extract.get_full_slug(),
'pk': midsize.pk
},
follow=True)
self.assertEqual(result.status_code, 200)
self.assertFalse(isfile(first_extract.get_path(True)))
midsize = PublishableContent.objects.filter(pk=midsize.pk).first()
midsize_draft = midsize.load_version()
second_container_draft = midsize_draft.children[1]
self.assertEqual(second_container_draft.children[0].title, first_extract.title)
self.assertTrue(second_container_draft.children[0].get_path(False))
# test try to move to a container that can't get extract
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.chapter1.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move near an extract that does not exist
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.chapter1.get_path(True) + '/un-mauvais-extrait',
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
def test_move_container_before(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.chapter3 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.chapter4 = ContainerFactory(parent=self.part2, db_object=self.tuto)
self.extract5 = ExtractFactory(container=self.chapter3, db_object=self.tuto)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for container (smoothly)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter3.slug,
'container_slug': self.part1.slug,
'first_level_slug': '',
'moving_method': 'before:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertTrue(isdir(chapter.get_path()))
self.assertEqual(1, len(chapter.children))
self.assertTrue(isfile(chapter.children[0].get_path()))
self.assertEqual(self.extract5.slug, chapter.children[0].slug)
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test changing parent for too deep container
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'before:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test moving before the root
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'before:' + self.tuto.load_version().get_path(),
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test moving without permission
self.client.logout()
self.assertEqual(
self.client.login(
username=self.user_guest.username,
password='******'),
True)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=False)
self.assertEqual(result.status_code, 403)
def test_move_extract_after(self):
# test 1 : move extract after a sibling
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
self.extract3 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.extract3.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[1]
self.assertEqual(self.extract3.slug, extract.slug)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for extract (smoothly)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.extract4 = ExtractFactory(container=self.chapter2, db_object=self.tuto)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.extract4.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move to a container that can't get extract
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.chapter1.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move near an extract that does not exist
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.chapter1.get_path(True) + '/un-mauvais-extrait',
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
def test_move_container_after(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.chapter3 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.extract5 = ExtractFactory(container=self.chapter3, db_object=self.tuto)
self.chapter4 = ContainerFactory(parent=self.part2, db_object=self.tuto)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for container (smoothly)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter3.slug,
'container_slug': self.part1.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(1, len(chapter.children))
self.assertTrue(isfile(chapter.children[0].get_path()))
self.assertEqual(self.extract5.slug, chapter.children[0].slug)
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test changing parent for too deep container
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
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 tearDown(self):
if os.path.isdir(settings.ZDS_APP['content']['repo_private_path']):
shutil.rmtree(settings.ZDS_APP['content']['repo_private_path'])
if os.path.isdir(settings.ZDS_APP['content']['repo_public_path']):
shutil.rmtree(settings.ZDS_APP['content']['repo_public_path'])
if os.path.isdir(settings.MEDIA_ROOT):
shutil.rmtree(settings.MEDIA_ROOT)
# re-activate PDF build
settings.ZDS_APP['content']['build_pdf_when_published'] = True
def test_boosts(self):
"""Check if boosts are doing their job"""
if not self.manager.connected_to_es:
return
# 1. Create topics (with identical titles), posts (with identical texts), an article and a tuto
text = 'test'
topic_1_solved_sticky = TopicFactory(forum=self.forum,
author=self.user)
topic_1_solved_sticky.title = text
topic_1_solved_sticky.subtitle = ''
topic_1_solved_sticky.is_solved = True
topic_1_solved_sticky.is_sticky = True
topic_1_solved_sticky.save()
post_1 = PostFactory(topic=topic_1_solved_sticky,
author=self.user,
position=1)
post_1.text = post_1.text_html = text
post_1.save()
post_2_useful = PostFactory(topic=topic_1_solved_sticky,
author=self.user,
position=2)
post_2_useful.text = post_2_useful.text_html = text
post_2_useful.is_useful = True
post_2_useful.like = 5
post_2_useful.dislike = 2 # l/d ratio above 1
post_2_useful.save()
topic_2_locked = TopicFactory(forum=self.forum,
author=self.user,
title=text)
topic_2_locked.title = text
topic_2_locked.subtitle = ''
topic_2_locked.is_locked = True
topic_2_locked.save()
post_3_ld_below_1 = PostFactory(topic=topic_2_locked,
author=self.user,
position=1)
post_3_ld_below_1.text = post_3_ld_below_1.text_html = text
post_3_ld_below_1.like = 2
post_3_ld_below_1.dislike = 5 # l/d ratio below 1
post_3_ld_below_1.save()
tuto = PublishableContentFactory(type='TUTORIAL')
tuto_draft = tuto.load_version()
tuto.title = text
tuto.authors.add(self.user)
tuto.save()
tuto_draft.repo_update_top_container(text, tuto.slug, text, text)
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter1.repo_update(text, 'Who cares ?', 'Same here')
ExtractFactory(container=chapter1, db_object=tuto)
published_tuto = 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
tuto.save()
article = PublishedContentFactory(type='ARTICLE', title=text)
published_article = PublishedContent.objects.get(content_pk=article.pk)
opinion_not_picked = PublishedContentFactory(type='OPINION',
title=text)
published_opinion_not_picked = PublishedContent.objects.get(
content_pk=opinion_not_picked.pk)
opinion_picked = PublishedContentFactory(type='OPINION', title=text)
opinion_picked.sha_picked = opinion_picked.sha_draft
opinion_picked.date_picked = datetime.datetime.now()
opinion_picked.save()
published_opinion_picked = PublishedContent.objects.get(
content_pk=opinion_picked.pk)
for model in self.indexable:
if model is FakeChapter:
continue
self.manager.es_bulk_indexing_of_model(model)
self.manager.refresh_index()
self.assertEqual(
len(
self.manager.setup_search(Search().query(
MatchAll())).execute()), 10)
# 2. Reset all boosts to 1
for doc_type in settings.ZDS_APP['search']['boosts']:
for key in settings.ZDS_APP['search']['boosts'][doc_type]:
settings.ZDS_APP['search']['boosts'][doc_type][key] = 1.0
# 3. Test posts
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Post.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
# score are equals without boost:
self.assertTrue(response[0].meta.score == response[1].meta.score ==
response[2].meta.score)
settings.ZDS_APP['search']['boosts']['post']['if_first'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Post.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score == response[1].meta.score >
response[2].meta.score)
self.assertEqual(response[2].meta.id, str(
post_2_useful.pk)) # post 2 is the only one not first
settings.ZDS_APP['search']['boosts']['post']['if_first'] = 1.0
settings.ZDS_APP['search']['boosts']['post']['if_useful'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Post.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score > response[1].meta.score ==
response[2].meta.score)
self.assertEqual(response[0].meta.id,
str(post_2_useful.pk)) # post 2 is useful
settings.ZDS_APP['search']['boosts']['post']['if_useful'] = 1.0
settings.ZDS_APP['search']['boosts']['post']['ld_ratio_above_1'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Post.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score > response[1].meta.score ==
response[2].meta.score)
self.assertEqual(response[0].meta.id, str(
post_2_useful.pk)) # post 2 have a l/d ratio of 5/2
settings.ZDS_APP['search']['boosts']['post']['ld_ratio_above_1'] = 1.0
settings.ZDS_APP['search']['boosts']['post'][
'ld_ratio_below_1'] = 2.0 # no one would do that in real life
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Post.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 3)
self.assertTrue(response[0].meta.score > response[1].meta.score ==
response[2].meta.score)
self.assertEqual(response[0].meta.id, str(
post_3_ld_below_1.pk)) # post 3 have a l/d ratio of 2/5
settings.ZDS_APP['search']['boosts']['post']['ld_ratio_below_1'] = 1.0
# 4. Test topics
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Topic.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
# score are equals without boost:
self.assertTrue(response[0].meta.score == response[1].meta.score)
settings.ZDS_APP['search']['boosts']['topic']['if_sticky'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Topic.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id,
str(topic_1_solved_sticky.pk)) # topic 1 is sticky
settings.ZDS_APP['search']['boosts']['topic']['if_sticky'] = 1.0
settings.ZDS_APP['search']['boosts']['topic']['if_solved'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Topic.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id,
str(topic_1_solved_sticky.pk)) # topic 1 is solved
settings.ZDS_APP['search']['boosts']['topic']['if_solved'] = 1.0
settings.ZDS_APP['search']['boosts']['topic'][
'if_locked'] = 2.0 # no one would do that in real life
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=' + Topic.get_es_document_type(),
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id,
str(topic_2_locked.pk)) # topic 2 is locked
settings.ZDS_APP['search']['boosts']['topic'][
'if_locked'] = 1.0 # no one would do that in real life
# 5. Test published contents
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
# score are equals without boost:
self.assertTrue(
response[0].meta.score == response[1].meta.score == response[2].
meta.score == response[3].meta.score == response[4].meta.score)
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_article'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id,
str(published_article.pk)) # obvious
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_article'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_tutorial'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id,
str(published_tuto.pk)) # obvious
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_tutorial'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_opinion'] = 2.0
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_opinion_not_picked'] = 4.0
# Note: in "real life", unpicked opinion would get a boost < 1.
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score >
response[2].meta.score)
self.assertEqual(
response[0].meta.id,
str(published_opinion_not_picked.pk)) # unpicked opinion got first
self.assertEqual(response[1].meta.id, str(published_opinion_picked.pk))
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_opinion'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_opinion_not_picked'] = 1.0
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_medium_or_big_tutorial'] = 2.0
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 5)
self.assertTrue(response[0].meta.score > response[1].meta.score)
self.assertEqual(response[0].meta.id,
str(published_tuto.pk)) # obvious
settings.ZDS_APP['search']['boosts']['publishedcontent'][
'if_medium_or_big_tutorial'] = 1.0
# 6. Test global boosts
# NOTE: score are NOT the same for all documents, no matter how hard it tries to, small differences exists
for model in self.indexable:
# set a huge number to overcome the small differences:
settings.ZDS_APP['search']['boosts'][
model.get_es_document_type()]['global'] = 10.0
result = self.client.get(reverse('search:query') + '?q=' + text,
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 10)
self.assertEqual(response[0].meta.doc_type,
model.get_es_document_type()) # obvious
settings.ZDS_APP['search']['boosts'][
model.get_es_document_type()]['global'] = 1.0
def test_move_extract_after(self):
# test 1 : move extract after a sibling
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
self.extract3 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.extract3.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[1]
self.assertEqual(self.extract3.slug, extract.slug)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for extract (smoothly)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.extract4 = ExtractFactory(container=self.chapter2, db_object=self.tuto)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.extract4.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move to a container that can't get extract
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.chapter1.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move near an extract that does not exist
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.chapter1.get_path(True) + '/un-mauvais-extrait',
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
def test_change_publishedcontents_impacts_chapter(self):
if not self.manager.connected_to_es:
return
# 1. Create middle-size content and index it
text = 'test'
tuto = PublishableContentFactory(type='TUTORIAL')
tuto_draft = tuto.load_version()
tuto.title = text
tuto.authors.add(self.user)
tuto.save()
tuto_draft.repo_update_top_container(
text, tuto.slug, text,
text) # change title to be sure it will match
chapter1 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter1.repo_update(text, text, text)
extract = ExtractFactory(container=chapter1, db_object=tuto)
extract.repo_update(text, text)
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()
self.manager.es_bulk_indexing_of_model(PublishedContent)
self.manager.refresh_index()
self.assertEqual(
len(
self.manager.setup_search(Search().query(
MatchAll())).execute()), 2) # indexing ok
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
self.assertEqual(response.hits.total, 2)
chapters = [r for r in response if r.meta.doc_type == 'chapter']
self.assertEqual(chapters[0].meta.doc_type,
FakeChapter.get_es_document_type())
self.assertEqual(chapters[0].meta.id,
published.content_public_slug + '__' + chapter1.slug)
# 2. Change tuto: delete chapter and insert new one !
tuto = PublishableContent.objects.get(pk=tuto.pk)
tuto_draft = tuto.load_version()
tuto_draft.children[0].repo_delete() # chapter 1 is gone !
another_text = 'another thing'
self.assertTrue(
text not in another_text
) # to prevent a future modification from breaking this test
chapter2 = ContainerFactory(parent=tuto_draft, db_object=tuto)
chapter2.repo_update(another_text, another_text, another_text)
extract2 = ExtractFactory(container=chapter2, db_object=tuto)
extract2.repo_update(another_text, another_text)
published = publish_content(tuto, tuto_draft, is_major_update=False)
tuto.sha_public = tuto_draft.current_version
tuto.sha_draft = tuto_draft.current_version
tuto.public_version = published
tuto.save()
self.manager.es_bulk_indexing_of_model(PublishedContent)
self.manager.refresh_index()
self.assertEqual(
len(
self.manager.setup_search(Search().query(
MatchAll())).execute()), 2) # 2 objects, not 3 !
result = self.client.get(reverse('search:query') + '?q=' + text +
'&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
contents = [r for r in response if r.meta.doc_type != 'chapter']
self.assertEqual(response.hits.total,
len(contents)) # no chapter found anymore
result = self.client.get(reverse('search:query') + '?q=' +
another_text + '&models=content',
follow=False)
self.assertEqual(result.status_code, 200)
response = result.context['object_list'].execute()
chapters = [r for r in response if r.meta.doc_type == 'chapter']
self.assertEqual(response.hits.total, 1)
self.assertEqual(chapters[0].meta.doc_type,
FakeChapter.get_es_document_type())
self.assertEqual(chapters[0].meta.id, published.content_public_slug +
'__' + chapter2.slug) # got new chapter
class PublicationFronttest(StaticLiveServerTestCase, TutorialTestMixin, TutorialFrontMixin):
@classmethod
def setUpClass(cls):
super(PublicationFronttest, cls).setUpClass()
cls.selenium = WebDriver()
cls.selenium.implicitly_wait(10)
@classmethod
def tearDownClass(cls):
cls.selenium.quit()
super(PublicationFronttest, cls).tearDownClass()
def tearDown(self):
super().tearDown()
self.clean_media_dir()
def setUp(self):
self.overridden_zds_app = overridden_zds_app
# don't build PDF to speed up the tests
overridden_zds_app['content']['build_pdf_when_published'] = False
self.staff = StaffProfileFactory().user
settings.EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend'
self.mas = ProfileFactory().user
overridden_zds_app['member']['bot_account'] = self.mas.username
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory()
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
self.content = PublishableContentFactory(author_list=[self.user_author], light=False)
self.part_published = ContainerFactory(db_object=self.content, light=False, parent=self.content.load_version())
self.ignored_part = ContainerFactory(db_object=self.content, light=False, parent=self.content.load_version())
ExtractFactory(db_object=self.content, container=self.part_published, light=False)
ExtractFactory(db_object=self.content, container=self.ignored_part, light=False)
def test_partial_publication(self):
self.login_author()
self.selenium.get(self.live_server_url + self.ignored_part.get_absolute_url())
find_element = self.selenium.find_element_by_css_selector
button = WebDriverWait(self.selenium, 20)\
.until(expected_conditions.element_to_be_clickable((By.CSS_SELECTOR, '.readiness')))
readiness = button.get_attribute('data-is-ready')
button.click()
self.wait_element_attribute_change((By.CSS_SELECTOR, '.readiness'), 'data-is-ready', readiness, 20)
self.content = PublishableContent.objects.get(pk=self.content.pk)
self.ignored_part = self.content.load_version().children[1]
self.assertFalse(self.ignored_part.ready_to_publish, 'part should be marked as not ready to publish')
self.selenium.get(self.live_server_url + self.content.get_absolute_url())
self.selenium.get(self.live_server_url + self.ignored_part.get_absolute_url())
button = find_element('.readiness')
self.assertNotEqual(readiness, button.get_attribute('data-is-ready'),
'part should be marked as not ready to publish')
self.selenium.get(self.live_server_url + self.content.get_absolute_url())
self.ask_validation()
self.logout()
self.login_staff()
self.take_reservation()
self.validate()
url = PublishedContent.objects.get(content__pk=self.content.pk).get_absolute_url_online()
self.selenium.get(self.live_server_url + url)
self.assertRaises(WebDriverException, find_element, 'a[href="{}"]'.format(
reverse('tutorial:view-container', kwargs={
'slug': self.content.slug,
'pk': self.content.pk,
'container_slug': self.ignored_part.slug
})))
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))
class ContentMoveTests(TutorialTestMixin, TestCase):
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 test_move_up_extract(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving up smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
# test moving up the first element
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug]\
.children_dict[self.chapter1.slug].children_dict[self.extract2.slug]
self.assertEqual(1, extract.position_in_parent)
# test moving without permission
self.client.logout()
self.assertEqual(
self.client.login(
username=self.user_guest.username,
password='******'),
True)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=False)
self.assertEqual(result.status_code, 403)
def test_move_extract_before(self):
# test 1 : move extract after a sibling
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
self.extract3 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.extract3.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for extract (smoothly)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.extract4 = ExtractFactory(container=self.chapter2, db_object=self.tuto)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.extract4.get_full_slug(),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test changing parents on a 'midsize content' (i.e depth of 1)
midsize = PublishableContentFactory(author_list=[self.user_author])
midsize_draft = midsize.load_version()
first_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
second_container = ContainerFactory(parent=midsize_draft, db_object=midsize)
first_extract = ExtractFactory(container=first_container, db_object=midsize)
second_extract = ExtractFactory(container=second_container, db_object=midsize)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': first_extract.slug,
'container_slug': first_container.get_path(True),
'first_level_slug': '',
'moving_method': 'before:' + second_extract.get_full_slug(),
'pk': midsize.pk
},
follow=True)
self.assertEqual(result.status_code, 200)
self.assertFalse(isfile(first_extract.get_path(True)))
midsize = PublishableContent.objects.filter(pk=midsize.pk).first()
midsize_draft = midsize.load_version()
second_container_draft = midsize_draft.children[1]
self.assertEqual(second_container_draft.children[0].title, first_extract.title)
self.assertTrue(second_container_draft.children[0].get_path(False))
# test try to move to a container that can't get extract
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.chapter1.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move near an extract that does not exist
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'before:' + self.chapter1.get_path(True) + '/un-mauvais-extrait',
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
def test_move_container_before(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.chapter3 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.chapter4 = ContainerFactory(parent=self.part2, db_object=self.tuto)
self.extract5 = ExtractFactory(container=self.chapter3, db_object=self.tuto)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for container (smoothly)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter3.slug,
'container_slug': self.part1.slug,
'first_level_slug': '',
'moving_method': 'before:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertTrue(isdir(chapter.get_path()))
self.assertEqual(1, len(chapter.children))
self.assertTrue(isfile(chapter.children[0].get_path()))
self.assertEqual(self.extract5.slug, chapter.children[0].slug)
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test changing parent for too deep container
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'before:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test moving before the root
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'before:' + self.tuto.load_version().get_path(),
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test moving without permission
self.client.logout()
self.assertEqual(
self.client.login(
username=self.user_guest.username,
password='******'),
True)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter2.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'up',
'pk': tuto.pk
},
follow=False)
self.assertEqual(result.status_code, 403)
def test_move_extract_after(self):
# test 1 : move extract after a sibling
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.extract2 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
self.extract3 = ExtractFactory(container=self.chapter1, db_object=self.tuto)
old_sha = tuto.sha_draft
# test moving smoothly
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.extract3.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[0]
self.assertEqual(self.extract2.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children[1]
self.assertEqual(self.extract3.slug, extract.slug)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for extract (smoothly)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.extract4 = ExtractFactory(container=self.chapter2, db_object=self.tuto)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter1.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.extract4.get_path(True)[:-3],
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move to a container that can't get extract
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.chapter1.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
# test try to move near an extract that does not exist
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.extract1.slug,
'container_slug': self.chapter2.slug,
'first_level_slug': self.part1.slug,
'moving_method': 'after:' + self.chapter1.get_path(True) + '/un-mauvais-extrait',
'pk': tuto.pk
},
follow=True)
self.assertEqual(404, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[1]
self.assertEqual(self.extract1.slug, extract.slug)
extract = versioned.children_dict[self.part1.slug].children_dict[self.chapter2.slug].children[0]
self.assertEqual(self.extract4.slug, extract.slug)
self.assertEqual(2, len(versioned.children_dict[self.part1.slug].children_dict[self.chapter1.slug].children))
def test_move_container_after(self):
# login with author
self.assertEqual(
self.client.login(
username=self.user_author.username,
password='******'),
True)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
self.chapter2 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.chapter3 = ContainerFactory(parent=self.part1, db_object=self.tuto)
self.part2 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto)
self.extract5 = ExtractFactory(container=self.chapter3, db_object=self.tuto)
self.chapter4 = ContainerFactory(parent=self.part2, db_object=self.tuto)
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
# test changing parent for container (smoothly)
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.chapter3.slug,
'container_slug': self.part1.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertNotEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(1, len(chapter.children))
self.assertTrue(isfile(chapter.children[0].get_path()))
self.assertEqual(self.extract5.slug, chapter.children[0].slug)
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
# test changing parent for too deep container
tuto = PublishableContent.objects.get(pk=self.tuto.pk)
old_sha = tuto.sha_draft
result = self.client.post(
reverse('content:move-element'),
{
'child_slug': self.part1.slug,
'container_slug': self.tuto.slug,
'first_level_slug': '',
'moving_method': 'after:' + self.chapter4.get_path(True),
'pk': tuto.pk
},
follow=True)
self.assertEqual(200, result.status_code)
self.assertEqual(old_sha, PublishableContent.objects.get(pk=tuto.pk).sha_draft)
versioned = PublishableContent.objects.get(pk=tuto.pk).load_version()
self.assertEqual(2, len(versioned.children_dict[self.part2.slug].children))
chapter = versioned.children_dict[self.part2.slug].children[1]
self.assertEqual(self.chapter3.slug, chapter.slug)
chapter = versioned.children_dict[self.part2.slug].children[0]
self.assertEqual(self.chapter4.slug, chapter.slug)
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()))
