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 publish_content(db_object, versioned, is_major_update=True):
"""
Publish a given content.
.. note::
create a manifest.json without the introduction and conclusion if not needed. Also remove the 'text' field
of extracts.
:param db_object: Database representation of the content
:type db_object: PublishableContent
:param versioned: version of the content to publish
:type versioned: VersionedContent
:param is_major_update: if set to `True`, will update the publication date
:type is_major_update: bool
:raise FailureDuringPublication: if something goes wrong
:return: the published representation
:rtype: zds.tutorialv2.models.models_database.PublishedContent
"""
from zds.tutorialv2.models.models_database import PublishedContent
if is_major_update:
versioned.pubdate = datetime.now()
# First write the files in a temporary directory: if anything goes wrong,
# the last published version is not impacted !
tmp_path = os.path.join(settings.ZDS_APP['content']['repo_public_path'], versioned.slug + '__building')
if os.path.exists(tmp_path):
shutil.rmtree(tmp_path) # erase previous attempt, if any
# render HTML:
altered_version = copy.deepcopy(versioned)
publish_container(db_object, tmp_path, altered_version)
altered_version.dump_json(os.path.join(tmp_path, 'manifest.json'))
# make room for 'extra contents'
extra_contents_path = os.path.join(tmp_path, settings.ZDS_APP['content']['extra_contents_dirname'])
os.makedirs(extra_contents_path)
base_name = os.path.join(extra_contents_path, versioned.slug)
# 1. markdown file (base for the others) :
# If we come from a command line, we need to activate i18n, to have the date in the french language.
cur_language = translation.get_language()
versioned.pubdate = datetime.now()
try:
translation.activate(settings.LANGUAGE_CODE)
parsed = render_to_string('tutorialv2/export/content.md', {'content': versioned})
finally:
translation.activate(cur_language)
parsed_with_local_images = retrieve_and_update_images_links(parsed, directory=extra_contents_path)
md_file_path = base_name + '.md'
md_file = codecs.open(md_file_path, 'w', encoding='utf-8')
try:
md_file.write(parsed_with_local_images)
except (UnicodeError, UnicodeEncodeError):
raise FailureDuringPublication(_('Une erreur est survenue durant la génération du fichier markdown '
'à télécharger, vérifiez le code markdown'))
finally:
md_file.close()
pandoc_debug_str = ''
if settings.PANDOC_LOG_STATE:
pandoc_debug_str = ' 2>&1 | tee -a ' + settings.PANDOC_LOG
if settings.ZDS_APP['content']['extra_content_generation_policy'] == 'SYNC':
# ok, now we can really publish the thing !
generate_exernal_content(base_name, extra_contents_path, md_file_path, pandoc_debug_str)
elif settings.ZDS_APP['content']['extra_content_generation_policy'] == 'WATCHDOG':
PublicatorRegistery.get('watchdog').publish(md_file_path, base_name, silently_pass=False)
is_update = False
if db_object.public_version:
public_version = db_object.public_version
is_update = True
# the content have been published in the past, so clean old files !
old_path = public_version.get_prod_path()
shutil.rmtree(old_path)
# if the slug change, instead of using the same object, a new one will be created
if versioned.slug != public_version.content_public_slug:
public_version.must_redirect = True # set redirection
publication_date = public_version.publication_date
public_version.save()
db_object.public_version = PublishedContent()
public_version = db_object.public_version
# if content have already been published, keep publication date !
public_version.publication_date = publication_date
else:
public_version = PublishedContent()
# make the new public version
public_version.content_public_slug = versioned.slug
public_version.content_type = versioned.type
public_version.content_pk = db_object.pk
public_version.content = db_object
public_version.must_reindex = True
public_version.save()
public_version.char_count = public_version.get_char_count(md_file_path)
for author in db_object.authors.all():
public_version.authors.add(author)
public_version.save()
# move the stuffs into the good position
if settings.ZDS_APP['content']['extra_content_generation_policy'] != 'WATCHDOG':
shutil.move(tmp_path, public_version.get_prod_path())
else: # if we use watchdog, we use copy to get md and zip file in prod but everything else will be handled by
# watchdog
shutil.copytree(tmp_path, public_version.get_prod_path())
# save public version
if is_major_update or not is_update:
public_version.publication_date = datetime.now()
elif is_update:
public_version.update_date = datetime.now()
public_version.sha_public = versioned.current_version
public_version.save()
try:
make_zip_file(public_version)
except OSError:
pass
return public_version