def test_compile_deep_tex(self):
"""Testet das Kompilieren einer tex-Datei mit Referenz auf eine Datei, welche in der Verzeichnishierarchie
unterhalb des angegebenen relativen Pfades liegt.
:return:
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im subfolder-Verzeichnis
image_name = "image.png"
shutil.copyfile(
os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche die Bild-Datei lediglich über ihren Namen (nicht aber über den relativen Pfad) referenziert
self.file_tex_dp = TexFile(name="deep.tex", folder=self.root)
self.file_tex_dp.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{image} \\end{document}'
self.file_tex_dp.save()
# kompiliert die referenzierende tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_dp.id,
formatid=0,
forcecompile=1)
# es sollte eine Fehlermeldung aufgetreten und keine pdf-Datei erzeugt worden sein
self.assertTrue(errors != None)
self.assertTrue(pdf == None)
def test_compile_img_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bestehende Bild-Datei referenziert.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im root-Verzeichnis des Projektes
# (verwendet logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
image_name = "image.png"
shutil.copyfile(
os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche eine Bild-Datei gültig referenziert
# (verwendet app/static/img/logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
self.file_tex_img = TexFile(name="img.tex", folder=self.root)
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{subfolder/image} \\end{document}'
self.file_tex_img.save()
# kompiliert die, die Bild-Datei referenzierende, tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_img.id,
formatid=0,
forcecompile=1)
# es sollten keine Fehlermeldungen auftreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Bild-Referenzierung auf eine nicht-existierende Bild-Datei
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{nosuchfile.jpg} \\end{document}'
self.file_tex_img.save()
# kompiliert die tex-Datei erneut
# (die Bild-Datei wurde nach obigem Kompilierprozess entfernt)
errors, pdf = compile.latexcompile(self.file_tex_img.id,
formatid=0,
forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger Bild-Referenz sollte zu einem FILENOTFOUND führen, wobei dennoch eine pdf-Datei erzeugt wird
self.assertTrue(
errors != None
) # and errors[1].startswith(ERROR_MESSAGES['COMPILATIONERROR_FILENOTFOUND']))
self.assertTrue(pdf != None)
def test_compile_deep_tex(self):
"""Testet das Kompilieren einer tex-Datei mit Referenz auf eine Datei, welche in der Verzeichnishierarchie
unterhalb des angegebenen relativen Pfades liegt.
:return:
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im subfolder-Verzeichnis
image_name = "image.png"
shutil.copyfile(os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche die Bild-Datei lediglich über ihren Namen (nicht aber über den relativen Pfad) referenziert
self.file_tex_dp = TexFile(name="deep.tex", folder=self.root)
self.file_tex_dp.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{image} \\end{document}'
self.file_tex_dp.save()
# kompiliert die referenzierende tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_dp.id, formatid=0, forcecompile=1)
# es sollte eine Fehlermeldung aufgetreten und keine pdf-Datei erzeugt worden sein
self.assertTrue(errors != None)
self.assertTrue(pdf == None)
def test_compile_bibtex_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bibtex-Datei referenziert,
deren Referenzen vollständig sind.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine bibtex-Datei im root-Verzeichnis des Projektes
self.file_bib = PlainTextFile(name="bibtex.bib", folder=self.root)
self.file_bib.source_code = "@article{a1, author=\"Author\", title=\"Titel\", journal=\"Magazin\", volume=\"1\", issue=\"1\", pages=\"42\", year=2014 }"
self.file_bib.save()
# erzeugt eine tex-Datei, welche die bibtex-Datei referenziert
self.file_tex_bibtex = TexFile(name="bib.tex", folder=self.root)
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{a1} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id,
formatid=0,
forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Referenzierung auf eine nicht-bestehende Referenz ~\cite{a2}
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{xyz} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id,
formatid=0,
forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger bibtex-Referenz sollte zu einem CITATIONUNDEFINED führen, wobei dennoch eine pdf-Datei erzeugt wird
# TODO
#self.assertTrue(errors!=None)
self.assertTrue(pdf != None)
def test_compile_img_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bestehende Bild-Datei referenziert.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im root-Verzeichnis des Projektes
# (verwendet logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
image_name = "image.png"
shutil.copyfile(os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche eine Bild-Datei gültig referenziert
# (verwendet app/static/img/logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
self.file_tex_img = TexFile(name="img.tex", folder=self.root)
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{subfolder/image} \\end{document}'
self.file_tex_img.save()
# kompiliert die, die Bild-Datei referenzierende, tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_img.id, formatid=0, forcecompile=1)
# es sollten keine Fehlermeldungen auftreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Bild-Referenzierung auf eine nicht-existierende Bild-Datei
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{nosuchfile.jpg} \\end{document}'
self.file_tex_img.save()
# kompiliert die tex-Datei erneut
# (die Bild-Datei wurde nach obigem Kompilierprozess entfernt)
errors, pdf = compile.latexcompile(self.file_tex_img.id, formatid=0, forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger Bild-Referenz sollte zu einem FILENOTFOUND führen, wobei dennoch eine pdf-Datei erzeugt wird
self.assertTrue(errors != None) # and errors[1].startswith(ERROR_MESSAGES['COMPILATIONERROR_FILENOTFOUND']))
self.assertTrue(pdf != None)
def test_compile_bibtex_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bibtex-Datei referenziert,
deren Referenzen vollständig sind.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine bibtex-Datei im root-Verzeichnis des Projektes
self.file_bib = PlainTextFile(name="bibtex.bib", folder=self.root)
self.file_bib.source_code = "@article{a1, author=\"Author\", title=\"Titel\", journal=\"Magazin\", volume=\"1\", issue=\"1\", pages=\"42\", year=2014 }"
self.file_bib.save()
# erzeugt eine tex-Datei, welche die bibtex-Datei referenziert
self.file_tex_bibtex = TexFile(name="bib.tex", folder=self.root)
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{a1} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id, formatid=0, forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Referenzierung auf eine nicht-bestehende Referenz ~\cite{a2}
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{xyz} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id, formatid=0, forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger bibtex-Referenz sollte zu einem CITATIONUNDEFINED führen, wobei dennoch eine pdf-Datei erzeugt wird
# TODO
#self.assertTrue(errors!=None)
self.assertTrue(pdf != None)
def setUpCollaborations(self):
self._user2_sharedproject = Project.objects.createWithMainTex(
name='user2_sharedproject', author=self._user2)
self._user2_sharedproject_folder1 = Folder.objects.create(
name='user2_sharedproject_folder1',
parent=self._user2_sharedproject.rootFolder,
root=self._user2_sharedproject.rootFolder)
self._user2_sharedproject_folder2 = Folder.objects.create(
name='user2_sharedproject_folder2',
parent=self._user2_sharedproject.rootFolder,
root=self._user2_sharedproject.rootFolder)
maintex = self._user2_sharedproject.rootFolder.getMainTex()
maintex.source_code = 'Hallo!'
maintex.save()
self._user2_sharedproject_folder1_texfile = TexFile(
name='temp.tex',
folder=self._user2_sharedproject_folder1,
source_code='invalidtex source code')
Collaboration.objects.create(user=self._user1,
project=self._user2_sharedproject,
isConfirmed=True)
class ViewTestCase(TestCase):
""" Klasse für Test Methoden der einzelnen Views.
"""
testfiles_root = os.path.join(settings.BASE_DIR, 'app', 'tests', 'server',
'static')
def setUpUserAndProjects(self):
"""Erstellt Benutzer und Projekte für die Tests.
Es werden 3 Benutzer erstellt:
- user1 hat 3 Projekte und 2 Vorlagen
- user2 hat 2 Projekte
- user3 hat keine Projekte
:return: None
"""
# erstelle user1
self._user1 = User.objects.create_user('*****@*****.**',
'*****@*****.**',
password='******')
self._user1._unhashedpw = '123456'
# erstelle user2
self._user2 = User.objects.create_user('*****@*****.**',
'*****@*****.**',
password='******')
self._user2._unhashedpw = 'test123'
# erstelle user3
self._user3 = User.objects.create_user('*****@*****.**',
'*****@*****.**',
password='******')
self._user3._unhashedpw = 'test123'
# logge user1 ein
self.client.login(username=self._user1.username,
password=self._user1._unhashedpw)
# erstelle ein Projekt als user1
self._user1_project1 = Project.objects.createWithMainTex(
name='user1_project1', author=self._user1)
self._user1_project2 = Project.objects.createWithMainTex(
name='user1_project2', author=self._user1)
self._user1_project3 = Project.objects.createWithMainTex(
name='user1_project3', author=self._user1)
self._user1_project4 = Project.objects.createWithMainTex(
name=u'Übungsprojekt 01', author=self._user1)
# erstelle eine Vorlage als user1
self._user1_template1 = ProjectTemplate.objects.create(
name='user1_template1', author=self._user1)
self._user1_template2 = ProjectTemplate.objects.create(
name='user1_template2', author=self._user1)
self._user1_template3 = ProjectTemplate.objects.create(
name=u'user1_template2´3', author=self._user1)
# erstelle ein Projekt als user2
self._user2_project1 = Project.objects.createWithMainTex(
name='user2_project1', author=self._user2)
self._user2_project2 = Project.objects.createWithMainTex(
name='user2_project2', author=self._user2)
self._user2_template1 = ProjectTemplate.objects.create(
name='user2_template1', author=self._user2)
def setUpCollaborations(self):
self._user2_sharedproject = Project.objects.createWithMainTex(
name='user2_sharedproject', author=self._user2)
self._user2_sharedproject_folder1 = Folder.objects.create(
name='user2_sharedproject_folder1',
parent=self._user2_sharedproject.rootFolder,
root=self._user2_sharedproject.rootFolder)
self._user2_sharedproject_folder2 = Folder.objects.create(
name='user2_sharedproject_folder2',
parent=self._user2_sharedproject.rootFolder,
root=self._user2_sharedproject.rootFolder)
maintex = self._user2_sharedproject.rootFolder.getMainTex()
maintex.source_code = 'Hallo!'
maintex.save()
self._user2_sharedproject_folder1_texfile = TexFile(
name='temp.tex',
folder=self._user2_sharedproject_folder1,
source_code='invalidtex source code')
Collaboration.objects.create(user=self._user1,
project=self._user2_sharedproject,
isConfirmed=True)
def setUpSingleUser(self):
"""Erstellt einen einzelnen Benutzer und loggt diesen ein.
:return: None
"""
# erstelle user1
self._user1 = User.objects.create_user('*****@*****.**',
'*****@*****.**',
password='******')
self._user1._unhashedpw = '123456'
# logge user1 ein
self.client.login(username=self._user1.username,
password=self._user1._unhashedpw)
def setUpFolders(self):
"""Erstellt mehrere Ordner in den Projekten von user1 und user2.
Es werden folgende Ordner erstellt:
user1_project1/folder1
user1_project1/folder2
user1_project1/folder2/subfolder1
user2_project1/folder1
user2_project1/folder1/subfolder1
:return: None
"""
# erstelle zwei Order für user1, die dem Projekt user1_project1 zugewiesen werden
# erstelle einen Unterordner in _user1_project1_folder2
self._user1_project1_folder1 = Folder(
name='user1_project1_folder1',
parent=self._user1_project1.rootFolder,
root=self._user1_project1.rootFolder)
self._user1_project1_folder1.save()
self._user1_project1_folder2 = Folder(
name='user1_project1_folder2',
parent=self._user1_project1.rootFolder,
root=self._user1_project1.rootFolder)
self._user1_project1_folder2.save()
self._user1_project1_folder2_subfolder1 = Folder(
name='user1_project1_folder2_subfolder1',
parent=self._user1_project1_folder2,
root=self._user1_project1.rootFolder)
self._user1_project1_folder2_subfolder1.save()
# erstelle zwei Order für user1, die dem Projekt user1_project4 zugewiesen werden
self._user1_project4_folder1 = Folder(
name=u'Übung 01',
parent=self._user1_project4.rootFolder,
root=self._user1_project4.rootFolder)
self._user1_project4_folder1.save()
self._user1_project4_folder2 = Folder(
name=u'Übung 02',
parent=self._user1_project4_folder1,
root=self._user1_project4.rootFolder)
self._user1_project4_folder2.save()
self._user1_project4_folder3 = Folder(
name=u'übung 02',
parent=self._user1_project4.rootFolder,
root=self._user1_project4.rootFolder)
self._user1_project4_folder3.save()
# erstelle zwei Order für user1, die der Vorlage user1_template1 zugewiesen werden
# erstelle einen Unterordner in _user1_template1_folder2
self._user1_template1_folder1 = Folder(
name='user1_template1_folder1',
parent=self._user1_template1.rootFolder,
root=self._user1_template1.rootFolder)
self._user1_template1_folder1.save()
self._user1_template1_folder2 = Folder(
name='user1_template1_folder2',
parent=self._user1_template1.rootFolder,
root=self._user1_template1.rootFolder)
self._user1_template1_folder2.save()
self._user1_template1_folder2_subfolder1 = Folder(
name='user1_template1_folder2_subfolder1',
parent=self._user1_template1_folder2,
root=self._user1_template1.rootFolder)
self._user1_template1_folder2_subfolder1.save()
# erstelle einen Order für user2, die dem Projekt user2_project1 zugewiesen werden
# erstelle einen Unterordner in _user2_project1_folder1
self._user2_project1_folder1 = Folder(
name='user2_project1_folder1',
parent=self._user2_project1.rootFolder,
root=self._user2_project1.rootFolder)
self._user2_project1_folder1.save()
self._user2_project1_folder1_subfolder1 = Folder(
name='user2_project1_folder1_subfolder1',
parent=self._user2_project1_folder1,
root=self._user1_project1.rootFolder)
self._user2_project1_folder1_subfolder1.save()
def setUpFiles(self):
"""Lädt mehrere Testdateien und speichert diese in der Datenbank.
Es werden folgende Dateien erstellt:
- user1: tex1 in project1_rootFolder (main.tex, es wird der sourc_code geändert)
- user1: tex2 in project1_rootFolder
- user1: tex3 in project1_rootFolder/folder1
- user1 : tex4
:return: None
"""
# Dateinamen der verwendeten Testdateien
texfile1_name = 'test_tex_presentation.tex'
texfile2_name = 'test_tex_simple.tex'
texfile3_name = 'test_tex_images.tex'
texfile4_name = 'test_tex_simple.tex'
texfile5_name = 'test_tex_simple.tex'
binfile1_name = 'test_bin.bin'
binfile2_name = 'test_jpg.jpg'
binfile3_name = 'test_png.png'
zipfile1_name = u'test_utf8_Übung.zip'
texfile1_name_specialchars = u'Übungsblatt01.tex'
texfile2_name_specialchars = u'Übungsblatt02.tex'
# Pfad für die zip
self._zipfile1_path = os.path.join(self.testfiles_root, zipfile1_name)
# Ändere den Source Code der main.tex Datei von user1_project1
self._user1_tex1 = self._user1_project1.rootFolder.getMainTex()
texfile1 = open(os.path.join(self.testfiles_root, texfile1_name), 'r')
self._user1_tex1_source_code = texfile1.read()
self._user1_tex1.source_code = self._user1_tex1_source_code
self._user1_tex1.save()
# Erstelle eine .tex Datei für user1 in user1_project1_root (Projekt root Verzeichnis)
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user1_tex2_source_code = texfile2.read()
self._user1_tex2 = TexFile(name=texfile2_name,
folder=self._user1_project1.rootFolder,
source_code=self._user1_tex2_source_code)
self._user1_tex2.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
texfile3 = open(os.path.join(self.testfiles_root, texfile3_name), 'r')
self._user1_tex3_source_code = texfile3.read()
self._user1_tex3 = TexFile(name=texfile3_name,
folder=self._user1_project1_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex3.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
self._user1_tex4 = TexFile(name=texfile2_name,
folder=self._user1_project1_folder1,
source_code='invalidtex source code')
self._user1_tex4.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex5_source_code = texfile3.read()
self._user1_tex5 = TexFile(name=texfile1_name_specialchars,
folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex5.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex6_source_code = texfile3.read()
self._user1_tex6 = TexFile(name=texfile2_name_specialchars,
folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex6.save()
# Erstelle eine Binärdatei für user1 in user1_project1_folder2_subfolder1
self._user1_binfile1_path = os.path.join(self.testfiles_root,
binfile1_name)
binfile1 = open(self._user1_binfile1_path, 'rb')
self._user1_binary1 = BinaryFile.objects.createFromFile(
name=binfile1_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile1)
binfile1.close()
# Ändere den Source Code der main.tex Datei von user2_project1
self._user2_tex1 = self._user2_project1.rootFolder.getMainTex()
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user2_tex1.source_code = texfile2.read()
self._user2_tex1.save()
# Erstelle eine jpg Bilddatei für user1 in user1_project1_folder2_subfolder1
self._user1_binary2_path = os.path.join(self.testfiles_root,
binfile2_name)
binfile2 = open(self._user1_binary2_path, 'rb')
self._user1_binary2 = BinaryFile.objects.createFromFile(
name=binfile2_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile2)
binfile2.close()
# Erstelle eine png Bilddatei für user1 in user1_project1_folder2_subfolder2
self._user1_binary3_path = os.path.join(self.testfiles_root,
binfile3_name)
binfile3 = open(self._user1_binary3_path, 'rb')
self._user1_binary3 = BinaryFile.objects.createFromFile(
name=binfile3_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile3)
binfile3.close()
# setzt einige Variablen, die in den Tests verwendet werden können
def setUpValues(self):
texfile_name = 'test_tex_simple.tex'
texfile = open(os.path.join(self.testfiles_root, texfile_name), 'r')
self._new_code1 = texfile.read()
texfile.close()
self._newtex_name1 = 'NeuerTexName1.tex'
self._newtex_name2 = 'NeuerTexName2.tex'
self._newtex_name3 = 'NeuerTexName3.tex'
self._newtex_name_only_ext = '.tex'
self._newtex_name_specialchars1 = u'übungsblatt 01.tex'
self._newtex_name_specialchars2 = u'übungsblatt 02.tex'
self._newbinary_name1 = 'NeuerBinaryName1.bin'
self._newbinary_name2 = 'NeuerBinaryName2.bin'
self._newbinary_name3 = 'NeuerBinaryName3.bin'
self._newname1 = 'NeuerName1'
self._newname2 = 'NeuerName2'
self._newname3 = 'NeuerName3'
self._newname4 = 'NeuerName4'
self._newname5 = 'NeuerName5'
self._invalidid = 100000000
self._name_only_spaces = ' '
self._name_blank = ''
self._name_invalid_chars = 'Test1234<>\\/'
self._name_no_ext = 'filename'
self._name_only_ext = '.tex'
# löscht den Ordner für die test Dateien
def tearDownFiles(self):
if os.path.isdir(settings.MEDIA_ROOT):
shutil.rmtree(settings.MEDIA_ROOT)
def setUpFiles(self):
"""Lädt mehrere Testdateien und speichert diese in der Datenbank.
Es werden folgende Dateien erstellt:
- user1: tex1 in project1_rootFolder (main.tex, es wird der sourc_code geändert)
- user1: tex2 in project1_rootFolder
- user1: tex3 in project1_rootFolder/folder1
- user1 : tex4
:return: None
"""
# Dateinamen der verwendeten Testdateien
texfile1_name = 'test_tex_presentation.tex'
texfile2_name = 'test_tex_simple.tex'
texfile3_name = 'test_tex_images.tex'
texfile4_name = 'test_tex_simple.tex'
texfile5_name = 'test_tex_simple.tex'
binfile1_name = 'test_bin.bin'
binfile2_name = 'test_jpg.jpg'
binfile3_name = 'test_png.png'
zipfile1_name = u'test_utf8_Übung.zip'
texfile1_name_specialchars = u'Übungsblatt01.tex'
texfile2_name_specialchars = u'Übungsblatt02.tex'
# Pfad für die zip
self._zipfile1_path = os.path.join(self.testfiles_root, zipfile1_name)
# Ändere den Source Code der main.tex Datei von user1_project1
self._user1_tex1 = self._user1_project1.rootFolder.getMainTex()
texfile1 = open(os.path.join(self.testfiles_root, texfile1_name), 'r')
self._user1_tex1_source_code = texfile1.read()
self._user1_tex1.source_code = self._user1_tex1_source_code
self._user1_tex1.save()
# Erstelle eine .tex Datei für user1 in user1_project1_root (Projekt root Verzeichnis)
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user1_tex2_source_code = texfile2.read()
self._user1_tex2 = TexFile(name=texfile2_name,
folder=self._user1_project1.rootFolder,
source_code=self._user1_tex2_source_code)
self._user1_tex2.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
texfile3 = open(os.path.join(self.testfiles_root, texfile3_name), 'r')
self._user1_tex3_source_code = texfile3.read()
self._user1_tex3 = TexFile(name=texfile3_name,
folder=self._user1_project1_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex3.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
self._user1_tex4 = TexFile(name=texfile2_name,
folder=self._user1_project1_folder1,
source_code='invalidtex source code')
self._user1_tex4.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex5_source_code = texfile3.read()
self._user1_tex5 = TexFile(name=texfile1_name_specialchars,
folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex5.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex6_source_code = texfile3.read()
self._user1_tex6 = TexFile(name=texfile2_name_specialchars,
folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex6.save()
# Erstelle eine Binärdatei für user1 in user1_project1_folder2_subfolder1
self._user1_binfile1_path = os.path.join(self.testfiles_root,
binfile1_name)
binfile1 = open(self._user1_binfile1_path, 'rb')
self._user1_binary1 = BinaryFile.objects.createFromFile(
name=binfile1_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile1)
binfile1.close()
# Ändere den Source Code der main.tex Datei von user2_project1
self._user2_tex1 = self._user2_project1.rootFolder.getMainTex()
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user2_tex1.source_code = texfile2.read()
self._user2_tex1.save()
# Erstelle eine jpg Bilddatei für user1 in user1_project1_folder2_subfolder1
self._user1_binary2_path = os.path.join(self.testfiles_root,
binfile2_name)
binfile2 = open(self._user1_binary2_path, 'rb')
self._user1_binary2 = BinaryFile.objects.createFromFile(
name=binfile2_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile2)
binfile2.close()
# Erstelle eine png Bilddatei für user1 in user1_project1_folder2_subfolder2
self._user1_binary3_path = os.path.join(self.testfiles_root,
binfile3_name)
binfile3 = open(self._user1_binary3_path, 'rb')
self._user1_binary3 = BinaryFile.objects.createFromFile(
name=binfile3_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile3)
binfile3.close()
def test_compile_tex(self):
"""Testet das (mehrfache) Kompilieren einer tex-Datei ohne Referenzen.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN EINER GÜLTIGEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# erzeugt eine gültige tex-Datei im root-Verzeichnis des Projektes
self.file_tex = TexFile(name="test.tex", folder=self.root)
self.file_tex.source_code = '\\documentclass{article} \\begin{document} \\LaTeX{} \\end{document}'
self.file_tex.save()
# kompiliert die gültige tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id, formatid=0, forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'], folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# ERNEUTES KOMPILIEREN DERSELBEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# kompiliert dieselbe tex-Datei ein weiteres Mal
errors, pdf = compile.latexcompile(self.file_tex.id, formatid=0, forcecompile=1)
# es sollten erneut keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun (genau) eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'], folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN DER LEEREN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# leert die tex-Datei
self.file_tex.source_code = ''
self.file_tex.save()
pdf_src[0].delete()
# kompiliert die leere tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id, formatid=0, forcecompile=1)
# das Kompilieren einer leeren tex-Datei sollte zu einem SYNTAXERROR führen, wobei keine pdf erzeugt wird
self.assertTrue(
errors != None) # and len(errors)==1 and errors[0].startswith(ERROR_MESSAGES['COMPILATIONERROR_SYNTAXERROR']))
#self.assertTrue(pdf == None)
# in der Datenbank sollte nun keine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=self.file_tex.name[:3] + 'pdf', folder=self.file_tex.folder)
self.assertTrue(pdf_src != None or len(pdf_src) == 0)
class CompilerTestClass(TestCase):
def setUp(self):
"""Setup Methode für die einzelnen Tests
Diese Funktion wird vor jeder Testfunktion ausgeführt.
Damit werden die notwendigen Variablen und Modelle für jeden Test neu initialisiert.
Die Methoden hierzu befinden sich im ViewTestCase (viewtestcase.py).
:return: None
"""
# erstellt einen neuen Benutzer
self.user = User.objects.create_user('*****@*****.**', '*****@*****.**', password='******')
# loggt den erzeugten Benutzer ein
self.client.login(username=self.user.username, password='******')
# ----------------------------------------------------------------------------------------------------
# VERZEICHNISSE
# ----------------------------------------------------------------------------------------------------
# erstellt ein neues Projekt für den erzeugten Benutzer
self.project = Project.objects.createWithMainTex(name='project', author=self.user)
self.root = self.project.rootFolder
# erzeugt ein Unterverzeichnis im root-Verzeichnis des Projektes
self.subfolder_path = os.path.join(self.root.getTempPath(), 'subfolder')
if not os.path.isdir(self.subfolder_path):
os.makedirs(self.subfolder_path)
def tearDown(self):
"""Freigabe von nicht mehr notwendigen Ressourcen.
Diese Funktion wird nach jeder Testfunktion ausgeführt.
:return: None
"""
# self.tearDownFiles()
pass
def test_compile_tex(self):
"""Testet das (mehrfache) Kompilieren einer tex-Datei ohne Referenzen.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN EINER GÜLTIGEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# erzeugt eine gültige tex-Datei im root-Verzeichnis des Projektes
self.file_tex = TexFile(name="test.tex", folder=self.root)
self.file_tex.source_code = '\\documentclass{article} \\begin{document} \\LaTeX{} \\end{document}'
self.file_tex.save()
# kompiliert die gültige tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id, formatid=0, forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'], folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# ERNEUTES KOMPILIEREN DERSELBEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# kompiliert dieselbe tex-Datei ein weiteres Mal
errors, pdf = compile.latexcompile(self.file_tex.id, formatid=0, forcecompile=1)
# es sollten erneut keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun (genau) eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'], folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN DER LEEREN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# leert die tex-Datei
self.file_tex.source_code = ''
self.file_tex.save()
pdf_src[0].delete()
# kompiliert die leere tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id, formatid=0, forcecompile=1)
# das Kompilieren einer leeren tex-Datei sollte zu einem SYNTAXERROR führen, wobei keine pdf erzeugt wird
self.assertTrue(
errors != None) # and len(errors)==1 and errors[0].startswith(ERROR_MESSAGES['COMPILATIONERROR_SYNTAXERROR']))
#self.assertTrue(pdf == None)
# in der Datenbank sollte nun keine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=self.file_tex.name[:3] + 'pdf', folder=self.file_tex.folder)
self.assertTrue(pdf_src != None or len(pdf_src) == 0)
def test_compile_img_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bestehende Bild-Datei referenziert.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im root-Verzeichnis des Projektes
# (verwendet logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
image_name = "image.png"
shutil.copyfile(os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche eine Bild-Datei gültig referenziert
# (verwendet app/static/img/logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
self.file_tex_img = TexFile(name="img.tex", folder=self.root)
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{subfolder/image} \\end{document}'
self.file_tex_img.save()
# kompiliert die, die Bild-Datei referenzierende, tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_img.id, formatid=0, forcecompile=1)
# es sollten keine Fehlermeldungen auftreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Bild-Referenzierung auf eine nicht-existierende Bild-Datei
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{nosuchfile.jpg} \\end{document}'
self.file_tex_img.save()
# kompiliert die tex-Datei erneut
# (die Bild-Datei wurde nach obigem Kompilierprozess entfernt)
errors, pdf = compile.latexcompile(self.file_tex_img.id, formatid=0, forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger Bild-Referenz sollte zu einem FILENOTFOUND führen, wobei dennoch eine pdf-Datei erzeugt wird
self.assertTrue(errors != None) # and errors[1].startswith(ERROR_MESSAGES['COMPILATIONERROR_FILENOTFOUND']))
self.assertTrue(pdf != None)
def test_compile_bibtex_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bibtex-Datei referenziert,
deren Referenzen vollständig sind.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine bibtex-Datei im root-Verzeichnis des Projektes
self.file_bib = PlainTextFile(name="bibtex.bib", folder=self.root)
self.file_bib.source_code = "@article{a1, author=\"Author\", title=\"Titel\", journal=\"Magazin\", volume=\"1\", issue=\"1\", pages=\"42\", year=2014 }"
self.file_bib.save()
# erzeugt eine tex-Datei, welche die bibtex-Datei referenziert
self.file_tex_bibtex = TexFile(name="bib.tex", folder=self.root)
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{a1} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id, formatid=0, forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Referenzierung auf eine nicht-bestehende Referenz ~\cite{a2}
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{xyz} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id, formatid=0, forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger bibtex-Referenz sollte zu einem CITATIONUNDEFINED führen, wobei dennoch eine pdf-Datei erzeugt wird
# TODO
#self.assertTrue(errors!=None)
self.assertTrue(pdf != None)
def test_compile_deep_tex(self):
"""Testet das Kompilieren einer tex-Datei mit Referenz auf eine Datei, welche in der Verzeichnishierarchie
unterhalb des angegebenen relativen Pfades liegt.
:return:
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im subfolder-Verzeichnis
image_name = "image.png"
shutil.copyfile(os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche die Bild-Datei lediglich über ihren Namen (nicht aber über den relativen Pfad) referenziert
self.file_tex_dp = TexFile(name="deep.tex", folder=self.root)
self.file_tex_dp.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{image} \\end{document}'
self.file_tex_dp.save()
# kompiliert die referenzierende tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_dp.id, formatid=0, forcecompile=1)
# es sollte eine Fehlermeldung aufgetreten und keine pdf-Datei erzeugt worden sein
self.assertTrue(errors != None)
self.assertTrue(pdf == None)
class ViewTestCase(TestCase):
""" Klasse für Test Methoden der einzelnen Views.
"""
testfiles_root = os.path.join(settings.BASE_DIR, 'app', 'tests', 'server', 'static')
def setUpUserAndProjects(self):
"""Erstellt Benutzer und Projekte für die Tests.
Es werden 3 Benutzer erstellt:
- user1 hat 3 Projekte und 2 Vorlagen
- user2 hat 2 Projekte
- user3 hat keine Projekte
:return: None
"""
# erstelle user1
self._user1 = User.objects.create_user('*****@*****.**', '*****@*****.**', password='******')
self._user1._unhashedpw = '123456'
# erstelle user2
self._user2 = User.objects.create_user('*****@*****.**', '*****@*****.**', password='******')
self._user2._unhashedpw = 'test123'
# erstelle user3
self._user3 = User.objects.create_user('*****@*****.**', '*****@*****.**', password='******')
self._user3._unhashedpw = 'test123'
# logge user1 ein
self.client.login(username=self._user1.username, password=self._user1._unhashedpw)
# erstelle ein Projekt als user1
self._user1_project1 = Project.objects.createWithMainTex(name='user1_project1', author=self._user1)
self._user1_project2 = Project.objects.createWithMainTex(name='user1_project2', author=self._user1)
self._user1_project3 = Project.objects.createWithMainTex(name='user1_project3', author=self._user1)
self._user1_project4 = Project.objects.createWithMainTex(name=u'Übungsprojekt 01', author=self._user1)
# erstelle eine Vorlage als user1
self._user1_template1 = ProjectTemplate.objects.create(name='user1_template1', author=self._user1)
self._user1_template2 = ProjectTemplate.objects.create(name='user1_template2', author=self._user1)
self._user1_template3 = ProjectTemplate.objects.create(name=u'user1_template2´3', author=self._user1)
# erstelle ein Projekt als user2
self._user2_project1 = Project.objects.createWithMainTex(name='user2_project1', author=self._user2)
self._user2_project2 = Project.objects.createWithMainTex(name='user2_project2', author=self._user2)
self._user2_template1 = ProjectTemplate.objects.create(name='user2_template1', author=self._user2)
def setUpCollaborations(self):
self._user2_sharedproject = Project.objects.createWithMainTex(name='user2_sharedproject', author=self._user2)
self._user2_sharedproject_folder1 = Folder.objects.create(name='user2_sharedproject_folder1',
parent=self._user2_sharedproject.rootFolder,
root=self._user2_sharedproject.rootFolder)
self._user2_sharedproject_folder2 = Folder.objects.create(name='user2_sharedproject_folder2',
parent=self._user2_sharedproject.rootFolder,
root=self._user2_sharedproject.rootFolder)
maintex = self._user2_sharedproject.rootFolder.getMainTex()
maintex.source_code = 'Hallo!'
maintex.save()
self._user2_sharedproject_folder1_texfile = TexFile(name='temp.tex', folder=self._user2_sharedproject_folder1,
source_code='invalidtex source code')
Collaboration.objects.create(user=self._user1, project=self._user2_sharedproject, isConfirmed=True)
def setUpSingleUser(self):
"""Erstellt einen einzelnen Benutzer und loggt diesen ein.
:return: None
"""
# erstelle user1
self._user1 = User.objects.create_user('*****@*****.**', '*****@*****.**', password='******')
self._user1._unhashedpw = '123456'
# logge user1 ein
self.client.login(username=self._user1.username, password=self._user1._unhashedpw)
def setUpFolders(self):
"""Erstellt mehrere Ordner in den Projekten von user1 und user2.
Es werden folgende Ordner erstellt:
user1_project1/folder1
user1_project1/folder2
user1_project1/folder2/subfolder1
user2_project1/folder1
user2_project1/folder1/subfolder1
:return: None
"""
# erstelle zwei Order für user1, die dem Projekt user1_project1 zugewiesen werden
# erstelle einen Unterordner in _user1_project1_folder2
self._user1_project1_folder1 = Folder(name='user1_project1_folder1', parent=self._user1_project1.rootFolder,
root=self._user1_project1.rootFolder)
self._user1_project1_folder1.save()
self._user1_project1_folder2 = Folder(name='user1_project1_folder2', parent=self._user1_project1.rootFolder,
root=self._user1_project1.rootFolder)
self._user1_project1_folder2.save()
self._user1_project1_folder2_subfolder1 = Folder(name='user1_project1_folder2_subfolder1',
parent=self._user1_project1_folder2,
root=self._user1_project1.rootFolder)
self._user1_project1_folder2_subfolder1.save()
# erstelle zwei Order für user1, die dem Projekt user1_project4 zugewiesen werden
self._user1_project4_folder1 = Folder(name=u'Übung 01', parent=self._user1_project4.rootFolder,
root=self._user1_project4.rootFolder)
self._user1_project4_folder1.save()
self._user1_project4_folder2 = Folder(name=u'Übung 02', parent=self._user1_project4_folder1,
root=self._user1_project4.rootFolder)
self._user1_project4_folder2.save()
self._user1_project4_folder3 = Folder(name=u'übung 02', parent=self._user1_project4.rootFolder,
root=self._user1_project4.rootFolder)
self._user1_project4_folder3.save()
# erstelle zwei Order für user1, die der Vorlage user1_template1 zugewiesen werden
# erstelle einen Unterordner in _user1_template1_folder2
self._user1_template1_folder1 = Folder(name='user1_template1_folder1', parent=self._user1_template1.rootFolder,
root=self._user1_template1.rootFolder)
self._user1_template1_folder1.save()
self._user1_template1_folder2 = Folder(name='user1_template1_folder2', parent=self._user1_template1.rootFolder,
root=self._user1_template1.rootFolder)
self._user1_template1_folder2.save()
self._user1_template1_folder2_subfolder1 = Folder(name='user1_template1_folder2_subfolder1',
parent=self._user1_template1_folder2,
root=self._user1_template1.rootFolder)
self._user1_template1_folder2_subfolder1.save()
# erstelle einen Order für user2, die dem Projekt user2_project1 zugewiesen werden
# erstelle einen Unterordner in _user2_project1_folder1
self._user2_project1_folder1 = Folder(name='user2_project1_folder1', parent=self._user2_project1.rootFolder,
root=self._user2_project1.rootFolder)
self._user2_project1_folder1.save()
self._user2_project1_folder1_subfolder1 = Folder(name='user2_project1_folder1_subfolder1',
parent=self._user2_project1_folder1,
root=self._user1_project1.rootFolder)
self._user2_project1_folder1_subfolder1.save()
def setUpFiles(self):
"""Lädt mehrere Testdateien und speichert diese in der Datenbank.
Es werden folgende Dateien erstellt:
- user1: tex1 in project1_rootFolder (main.tex, es wird der sourc_code geändert)
- user1: tex2 in project1_rootFolder
- user1: tex3 in project1_rootFolder/folder1
- user1 : tex4
:return: None
"""
# Dateinamen der verwendeten Testdateien
texfile1_name = 'test_tex_presentation.tex'
texfile2_name = 'test_tex_simple.tex'
texfile3_name = 'test_tex_images.tex'
texfile4_name = 'test_tex_simple.tex'
texfile5_name = 'test_tex_simple.tex'
binfile1_name = 'test_bin.bin'
binfile2_name = 'test_jpg.jpg'
binfile3_name = 'test_png.png'
zipfile1_name = u'test_utf8_Übung.zip'
texfile1_name_specialchars = u'Übungsblatt01.tex'
texfile2_name_specialchars = u'Übungsblatt02.tex'
# Pfad für die zip
self._zipfile1_path = os.path.join(self.testfiles_root, zipfile1_name)
# Ändere den Source Code der main.tex Datei von user1_project1
self._user1_tex1 = self._user1_project1.rootFolder.getMainTex()
texfile1 = open(os.path.join(self.testfiles_root, texfile1_name), 'r')
self._user1_tex1_source_code = texfile1.read()
self._user1_tex1.source_code = self._user1_tex1_source_code
self._user1_tex1.save()
# Erstelle eine .tex Datei für user1 in user1_project1_root (Projekt root Verzeichnis)
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user1_tex2_source_code = texfile2.read()
self._user1_tex2 = TexFile(name=texfile2_name, folder=self._user1_project1.rootFolder,
source_code=self._user1_tex2_source_code)
self._user1_tex2.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
texfile3 = open(os.path.join(self.testfiles_root, texfile3_name), 'r')
self._user1_tex3_source_code = texfile3.read()
self._user1_tex3 = TexFile(name=texfile3_name, folder=self._user1_project1_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex3.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
self._user1_tex4 = TexFile(name=texfile2_name, folder=self._user1_project1_folder1,
source_code='invalidtex source code')
self._user1_tex4.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex5_source_code = texfile3.read()
self._user1_tex5 = TexFile(name=texfile1_name_specialchars, folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex5.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex6_source_code = texfile3.read()
self._user1_tex6 = TexFile(name=texfile2_name_specialchars, folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex6.save()
# Erstelle eine Binärdatei für user1 in user1_project1_folder2_subfolder1
self._user1_binfile1_path = os.path.join(self.testfiles_root, binfile1_name)
binfile1 = open(self._user1_binfile1_path, 'rb')
self._user1_binary1 = BinaryFile.objects.createFromFile(name=binfile1_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile1)
binfile1.close()
# Ändere den Source Code der main.tex Datei von user2_project1
self._user2_tex1 = self._user2_project1.rootFolder.getMainTex()
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user2_tex1.source_code = texfile2.read()
self._user2_tex1.save()
# Erstelle eine jpg Bilddatei für user1 in user1_project1_folder2_subfolder1
self._user1_binary2_path = os.path.join(self.testfiles_root, binfile2_name)
binfile2 = open(self._user1_binary2_path, 'rb')
self._user1_binary2 = BinaryFile.objects.createFromFile(name=binfile2_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile2)
binfile2.close()
# Erstelle eine png Bilddatei für user1 in user1_project1_folder2_subfolder2
self._user1_binary3_path = os.path.join(self.testfiles_root, binfile3_name)
binfile3 = open(self._user1_binary3_path, 'rb')
self._user1_binary3 = BinaryFile.objects.createFromFile(name=binfile3_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile3)
binfile3.close()
# setzt einige Variablen, die in den Tests verwendet werden können
def setUpValues(self):
texfile_name = 'test_tex_simple.tex'
texfile = open(os.path.join(self.testfiles_root, texfile_name), 'r')
self._new_code1 = texfile.read()
texfile.close()
self._newtex_name1 = 'NeuerTexName1.tex'
self._newtex_name2 = 'NeuerTexName2.tex'
self._newtex_name3 = 'NeuerTexName3.tex'
self._newtex_name_only_ext = '.tex'
self._newtex_name_specialchars1 = u'übungsblatt 01.tex'
self._newtex_name_specialchars2 = u'übungsblatt 02.tex'
self._newbinary_name1 = 'NeuerBinaryName1.bin'
self._newbinary_name2 = 'NeuerBinaryName2.bin'
self._newbinary_name3 = 'NeuerBinaryName3.bin'
self._newname1 = 'NeuerName1'
self._newname2 = 'NeuerName2'
self._newname3 = 'NeuerName3'
self._newname4 = 'NeuerName4'
self._newname5 = 'NeuerName5'
self._invalidid = 100000000
self._name_only_spaces = ' '
self._name_blank = ''
self._name_invalid_chars = 'Test1234<>\\/'
self._name_no_ext = 'filename'
self._name_only_ext = '.tex'
# löscht den Ordner für die test Dateien
def tearDownFiles(self):
if os.path.isdir(settings.MEDIA_ROOT):
shutil.rmtree(settings.MEDIA_ROOT)
def setUpFiles(self):
"""Lädt mehrere Testdateien und speichert diese in der Datenbank.
Es werden folgende Dateien erstellt:
- user1: tex1 in project1_rootFolder (main.tex, es wird der sourc_code geändert)
- user1: tex2 in project1_rootFolder
- user1: tex3 in project1_rootFolder/folder1
- user1 : tex4
:return: None
"""
# Dateinamen der verwendeten Testdateien
texfile1_name = 'test_tex_presentation.tex'
texfile2_name = 'test_tex_simple.tex'
texfile3_name = 'test_tex_images.tex'
texfile4_name = 'test_tex_simple.tex'
texfile5_name = 'test_tex_simple.tex'
binfile1_name = 'test_bin.bin'
binfile2_name = 'test_jpg.jpg'
binfile3_name = 'test_png.png'
zipfile1_name = u'test_utf8_Übung.zip'
texfile1_name_specialchars = u'Übungsblatt01.tex'
texfile2_name_specialchars = u'Übungsblatt02.tex'
# Pfad für die zip
self._zipfile1_path = os.path.join(self.testfiles_root, zipfile1_name)
# Ändere den Source Code der main.tex Datei von user1_project1
self._user1_tex1 = self._user1_project1.rootFolder.getMainTex()
texfile1 = open(os.path.join(self.testfiles_root, texfile1_name), 'r')
self._user1_tex1_source_code = texfile1.read()
self._user1_tex1.source_code = self._user1_tex1_source_code
self._user1_tex1.save()
# Erstelle eine .tex Datei für user1 in user1_project1_root (Projekt root Verzeichnis)
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user1_tex2_source_code = texfile2.read()
self._user1_tex2 = TexFile(name=texfile2_name, folder=self._user1_project1.rootFolder,
source_code=self._user1_tex2_source_code)
self._user1_tex2.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
texfile3 = open(os.path.join(self.testfiles_root, texfile3_name), 'r')
self._user1_tex3_source_code = texfile3.read()
self._user1_tex3 = TexFile(name=texfile3_name, folder=self._user1_project1_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex3.save()
# Erstelle eine .tex Datei für user1 in user1_project1_folder1
self._user1_tex4 = TexFile(name=texfile2_name, folder=self._user1_project1_folder1,
source_code='invalidtex source code')
self._user1_tex4.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex5_source_code = texfile3.read()
self._user1_tex5 = TexFile(name=texfile1_name_specialchars, folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex5.save()
# Erstelle eine .tex Datei für user1 in user1_project4_folder1
texfile3.seek(0)
self._user1_tex6_source_code = texfile3.read()
self._user1_tex6 = TexFile(name=texfile2_name_specialchars, folder=self._user1_project4_folder1,
source_code=self._user1_tex3_source_code)
self._user1_tex6.save()
# Erstelle eine Binärdatei für user1 in user1_project1_folder2_subfolder1
self._user1_binfile1_path = os.path.join(self.testfiles_root, binfile1_name)
binfile1 = open(self._user1_binfile1_path, 'rb')
self._user1_binary1 = BinaryFile.objects.createFromFile(name=binfile1_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile1)
binfile1.close()
# Ändere den Source Code der main.tex Datei von user2_project1
self._user2_tex1 = self._user2_project1.rootFolder.getMainTex()
texfile2 = open(os.path.join(self.testfiles_root, texfile2_name), 'r')
self._user2_tex1.source_code = texfile2.read()
self._user2_tex1.save()
# Erstelle eine jpg Bilddatei für user1 in user1_project1_folder2_subfolder1
self._user1_binary2_path = os.path.join(self.testfiles_root, binfile2_name)
binfile2 = open(self._user1_binary2_path, 'rb')
self._user1_binary2 = BinaryFile.objects.createFromFile(name=binfile2_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile2)
binfile2.close()
# Erstelle eine png Bilddatei für user1 in user1_project1_folder2_subfolder2
self._user1_binary3_path = os.path.join(self.testfiles_root, binfile3_name)
binfile3 = open(self._user1_binary3_path, 'rb')
self._user1_binary3 = BinaryFile.objects.createFromFile(name=binfile3_name,
folder=self._user1_project1_folder2_subfolder1,
file=binfile3)
binfile3.close()
def test_compile_tex(self):
"""Testet das (mehrfache) Kompilieren einer tex-Datei ohne Referenzen.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN EINER GÜLTIGEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# erzeugt eine gültige tex-Datei im root-Verzeichnis des Projektes
self.file_tex = TexFile(name="test.tex", folder=self.root)
self.file_tex.source_code = '\\documentclass{article} \\begin{document} \\LaTeX{} \\end{document}'
self.file_tex.save()
# kompiliert die gültige tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id,
formatid=0,
forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'],
folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# ERNEUTES KOMPILIEREN DERSELBEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# kompiliert dieselbe tex-Datei ein weiteres Mal
errors, pdf = compile.latexcompile(self.file_tex.id,
formatid=0,
forcecompile=1)
# es sollten erneut keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun (genau) eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'],
folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN DER LEEREN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# leert die tex-Datei
self.file_tex.source_code = ''
self.file_tex.save()
pdf_src[0].delete()
# kompiliert die leere tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id,
formatid=0,
forcecompile=1)
# das Kompilieren einer leeren tex-Datei sollte zu einem SYNTAXERROR führen, wobei keine pdf erzeugt wird
self.assertTrue(
errors != None
) # and len(errors)==1 and errors[0].startswith(ERROR_MESSAGES['COMPILATIONERROR_SYNTAXERROR']))
#self.assertTrue(pdf == None)
# in der Datenbank sollte nun keine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=self.file_tex.name[:3] + 'pdf',
folder=self.file_tex.folder)
self.assertTrue(pdf_src != None or len(pdf_src) == 0)
class CompilerTestClass(TestCase):
def setUp(self):
"""Setup Methode für die einzelnen Tests
Diese Funktion wird vor jeder Testfunktion ausgeführt.
Damit werden die notwendigen Variablen und Modelle für jeden Test neu initialisiert.
Die Methoden hierzu befinden sich im ViewTestCase (viewtestcase.py).
:return: None
"""
# erstellt einen neuen Benutzer
self.user = User.objects.create_user('*****@*****.**',
'*****@*****.**',
password='******')
# loggt den erzeugten Benutzer ein
self.client.login(username=self.user.username, password='******')
# ----------------------------------------------------------------------------------------------------
# VERZEICHNISSE
# ----------------------------------------------------------------------------------------------------
# erstellt ein neues Projekt für den erzeugten Benutzer
self.project = Project.objects.createWithMainTex(name='project',
author=self.user)
self.root = self.project.rootFolder
# erzeugt ein Unterverzeichnis im root-Verzeichnis des Projektes
self.subfolder_path = os.path.join(self.root.getTempPath(),
'subfolder')
if not os.path.isdir(self.subfolder_path):
os.makedirs(self.subfolder_path)
def tearDown(self):
"""Freigabe von nicht mehr notwendigen Ressourcen.
Diese Funktion wird nach jeder Testfunktion ausgeführt.
:return: None
"""
# self.tearDownFiles()
pass
def test_compile_tex(self):
"""Testet das (mehrfache) Kompilieren einer tex-Datei ohne Referenzen.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN EINER GÜLTIGEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# erzeugt eine gültige tex-Datei im root-Verzeichnis des Projektes
self.file_tex = TexFile(name="test.tex", folder=self.root)
self.file_tex.source_code = '\\documentclass{article} \\begin{document} \\LaTeX{} \\end{document}'
self.file_tex.save()
# kompiliert die gültige tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id,
formatid=0,
forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'],
folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# ERNEUTES KOMPILIEREN DERSELBEN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# kompiliert dieselbe tex-Datei ein weiteres Mal
errors, pdf = compile.latexcompile(self.file_tex.id,
formatid=0,
forcecompile=1)
# es sollten erneut keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# in der Datenbank sollte nun (genau) eine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=pdf['name'],
folder=self.file_tex.folder)
self.assertTrue(pdf_src != None and len(pdf_src) == 1)
# ----------------------------------------------------------------------------------------------------
# KOMPILIEREN DER LEEREN TEX-DATEI
# ----------------------------------------------------------------------------------------------------
# leert die tex-Datei
self.file_tex.source_code = ''
self.file_tex.save()
pdf_src[0].delete()
# kompiliert die leere tex-Datei
errors, pdf = compile.latexcompile(self.file_tex.id,
formatid=0,
forcecompile=1)
# das Kompilieren einer leeren tex-Datei sollte zu einem SYNTAXERROR führen, wobei keine pdf erzeugt wird
self.assertTrue(
errors != None
) # and len(errors)==1 and errors[0].startswith(ERROR_MESSAGES['COMPILATIONERROR_SYNTAXERROR']))
#self.assertTrue(pdf == None)
# in der Datenbank sollte nun keine entsprechende pdf-Datei vorliegen
pdf_src = PDF.objects.filter(name=self.file_tex.name[:3] + 'pdf',
folder=self.file_tex.folder)
self.assertTrue(pdf_src != None or len(pdf_src) == 0)
def test_compile_img_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bestehende Bild-Datei referenziert.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im root-Verzeichnis des Projektes
# (verwendet logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
image_name = "image.png"
shutil.copyfile(
os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche eine Bild-Datei gültig referenziert
# (verwendet app/static/img/logo.png als echte Bild-Datei, da leere Bild-Dateien nicht kompilierbar sind)
self.file_tex_img = TexFile(name="img.tex", folder=self.root)
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{subfolder/image} \\end{document}'
self.file_tex_img.save()
# kompiliert die, die Bild-Datei referenzierende, tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_img.id,
formatid=0,
forcecompile=1)
# es sollten keine Fehlermeldungen auftreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Bild-Referenzierung auf eine nicht-existierende Bild-Datei
self.file_tex_img.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{nosuchfile.jpg} \\end{document}'
self.file_tex_img.save()
# kompiliert die tex-Datei erneut
# (die Bild-Datei wurde nach obigem Kompilierprozess entfernt)
errors, pdf = compile.latexcompile(self.file_tex_img.id,
formatid=0,
forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger Bild-Referenz sollte zu einem FILENOTFOUND führen, wobei dennoch eine pdf-Datei erzeugt wird
self.assertTrue(
errors != None
) # and errors[1].startswith(ERROR_MESSAGES['COMPILATIONERROR_FILENOTFOUND']))
self.assertTrue(pdf != None)
def test_compile_bibtex_tex(self):
"""Testet das Kompilieren einer tex-Datei, welche auf eine bibtex-Datei referenziert,
deren Referenzen vollständig sind.
:return: None
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine bibtex-Datei im root-Verzeichnis des Projektes
self.file_bib = PlainTextFile(name="bibtex.bib", folder=self.root)
self.file_bib.source_code = "@article{a1, author=\"Author\", title=\"Titel\", journal=\"Magazin\", volume=\"1\", issue=\"1\", pages=\"42\", year=2014 }"
self.file_bib.save()
# erzeugt eine tex-Datei, welche die bibtex-Datei referenziert
self.file_tex_bibtex = TexFile(name="bib.tex", folder=self.root)
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{a1} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id,
formatid=0,
forcecompile=1)
# es sollten keine Fehlermeldungen aufgetreten und eine pdf-Datei erzeugt worden sein
self.assertTrue(errors == None)
self.assertTrue(pdf != None)
# ----------------------------------------------------------------------------------------------------
# UNGÜLTIGE BIBTEX-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# ändert die Referenzierung auf eine nicht-bestehende Referenz ~\cite{a2}
self.file_tex_bibtex.source_code = '\\documentclass{article} \\begin{document} \\bibliographystyle{plain} Test~\\cite{xyz} \\bibliography{bibtex} \\end{document}'
self.file_tex_bibtex.save()
# kompiliert die tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_bibtex.id,
formatid=0,
forcecompile=1)
# das Kompilieren einer tex-Datei mit ungültiger bibtex-Referenz sollte zu einem CITATIONUNDEFINED führen, wobei dennoch eine pdf-Datei erzeugt wird
# TODO
#self.assertTrue(errors!=None)
self.assertTrue(pdf != None)
def test_compile_deep_tex(self):
"""Testet das Kompilieren einer tex-Datei mit Referenz auf eine Datei, welche in der Verzeichnishierarchie
unterhalb des angegebenen relativen Pfades liegt.
:return:
"""
# ----------------------------------------------------------------------------------------------------
# GÜLTIGE BILD-REFERENZIERUNG
# ----------------------------------------------------------------------------------------------------
# erzeugt eine Bild-Datei im subfolder-Verzeichnis
image_name = "image.png"
shutil.copyfile(
os.path.join(BASE_DIR, "app", "static", "img", "logo.png"),
os.path.join(self.subfolder_path, image_name))
# erzeugt eine tex-Datei, welche die Bild-Datei lediglich über ihren Namen (nicht aber über den relativen Pfad) referenziert
self.file_tex_dp = TexFile(name="deep.tex", folder=self.root)
self.file_tex_dp.source_code = '\\documentclass{article} \\usepackage{graphicx} \\begin{document} \\includegraphics{image} \\end{document}'
self.file_tex_dp.save()
# kompiliert die referenzierende tex-Datei
errors, pdf = compile.latexcompile(self.file_tex_dp.id,
formatid=0,
forcecompile=1)
# es sollte eine Fehlermeldung aufgetreten und keine pdf-Datei erzeugt worden sein
self.assertTrue(errors != None)
self.assertTrue(pdf == None)