def test_templateRm(self):
"""Test der templateRm() Methode aus dem template view
Teste das Löschen einer Vorlage von einem Benutzer.
Testfälle:
- user1 löscht eine vorhandene Vorlage -> Erfolg
- user1 löscht eine nicht vorhandene Vorlage -> Fehler
- user1 löscht eine Vorlage welche user2 gehört -> Fehler
:return: None
"""
# Sende Anfrage zum Löschen einer vorhandenen Vorlage
response = util.documentPoster(self, command='templaterm', idpara=self._user1_template1.id)
# es sollten keine Ordner der Vorlage mehr in der Datenbank existieren
self.assertFalse(Folder.objects.filter(id=self._user1_template1_folder1.id))
self.assertFalse(Folder.objects.filter(id=self._user1_template1_folder2_subfolder1.id))
# erwartete Antwort des Servers
serveranswer = {}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Löschen eines nicht vorhandenen Projektes
response = util.documentPoster(self, command='templaterm', idpara=self._invalidid)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['TEMPLATENOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Löschen eines Projektes von user2 (als user1)
response = util.documentPoster(self, command='templaterm', idpara=self._user2_template1.id)
# das Projekt sollte nicht gelöscht worden sein
self.assertTrue(ProjectTemplate.objects.get(id=self._user2_template1.id))
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
def test_listtemplates(self):
"""Test der listtemplates() Methode aus dem template view.
Teste das Auflisten von Vorlagen eines Benutzers
Testfälle:
- user1 fordert eine Liste aller Vorlagen an -> Erfolg
:returns: None
"""
# Sende Anfrage zum Auflisten aller Vorlagen
response = util.documentPoster(
self, command='listtemplates')
# erwartete Antwort des Servers
serveranswer = [
{
"ownername": self._user1_template1.author.username,
"rootid": self._user1_template1.rootFolder.id,
"id": self._user1_template1.id,
"createtime": util.datetimeToString(self._user1_template1.createTime),
"ownerid": self._user1_template1.author.id,
"name": self._user1_template1.name,
},
{
"ownername": self._user1_template2.author.username,
"rootid": self._user1_template2.rootFolder.id,
"id": self._user1_template2.id,
"createtime": util.datetimeToString(self._user1_template2.createTime),
"ownerid": self._user1_template2.author.id,
"name": self._user1_template2.name,
},
{
"ownername": self._user1_template3.author.username,
"rootid": self._user1_template3.rootFolder.id,
"id": self._user1_template3.id,
"createtime": util.datetimeToString(self._user1_template3.createTime),
"ownerid": self._user1_template3.author.id,
"name": self._user1_template3.name,
},
]
# überprüfe die Antwort des Servers
# status sollte success sein
# teste, ob in response die beiden erstellten Vorlagen von user1 richtig aufgelistet werden
# und keine Vorlagen von user2 aufgelistet werden
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
def test_listFiles(self):
"""Test der listFiles() Methode des folder view
Teste das Auflisten der Datei- und Ordnerstruktur eines Ordners.
Testfälle:
- user2 listet Dateien und Ordner des project1 auf -> Erfolg
- user1 listet Dateien und Ordner des project1 auf -> Erfolg
- user1 listet Dateien und Ordner eines Projektes auf welches user2 gehört -> Fehler
- user1 listet Dateien und Ordner eines nicht vorhandenen Ordners auf -> Fehler
- user1 listet Dateien des freigegebenen project2 von user2 (Einladung ist nicht bestätigt) -> Fehler
- user1 listet Dateien des freigegebenen project2 von user2 (Einladung ist bestätigt) -> Erfold
:return: None
"""
# logge user2 ein
self.client.logout()
self.client.login(username=self._user2.username, password=self._user2._unhashedpw)
# Sende Anfrage der Datei- und Ordnerstruktur von _user2_project1 (rootFolder)
# (Aufbau siehe SetUp Methoden in viewtestcase.py)
response = util.documentPoster(self, command='listfiles', idpara=self._user2_project1.rootFolder.id)
# hole das rootFolder und maintex Objekt
rootfolder = self._user2_project1.rootFolder
maintex = rootfolder.getMainTex()
# erwartete Antwort des Servers
serveranswer = {
'id': rootfolder.id,
'name': rootfolder.name,
'project': rootfolder.getProject().name,
'files': [
{'id': maintex.id,
'name': maintex.name,
'mimetype': maintex.mimeType,
'size': maintex.size,
'createTime': str(maintex.createTime),
'lastModifiedTime': str(maintex.lastModifiedTime),
'isAllowEdit': True}
],
'folders': [{
'id': self._user2_project1_folder1.id,
'name': self._user2_project1_folder1.name,
'folders': [
{'id': self._user2_project1_folder1_subfolder1.id,
'name': self._user2_project1_folder1_subfolder1.name,
'files': [],
'folders': []},
],
'files': [],
}]
}
# überprüfe die Antwort des Servers
# sollte success als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# logge user1 ein
self.client.logout()
self.client.login(username=self._user1.username, password=self._user1._unhashedpw)
# Sende Anfrage der Datei- und Ordnerstruktur von _user1_project1 (rootFolder)
# (Aufbau siehe SetUp Methoden in viewtestcase.py)
response = util.documentPoster(self, command='listfiles', idpara=self._user1_project1.rootFolder.id)
# hole das rootFolder und maintex Objekt
rootfolder = self._user1_project1.rootFolder
maintex = rootfolder.getMainTex()
# erwartete Antwort des Servers
serveranswer = {
'id': rootfolder.id,
'name': rootfolder.name,
'project': rootfolder.getProject().name,
'files': [
{'id': maintex.id,
'name': maintex.name,
'mimetype': maintex.mimeType,
'size': maintex.size,
'createTime': str(maintex.createTime),
'lastModifiedTime': str(maintex.lastModifiedTime),
'isAllowEdit': True},
{'id': self._user1_tex2.id,
'name': self._user1_tex2.name,
'mimetype': self._user1_tex2.mimeType,
'size': self._user1_tex2.size,
'createTime': str(self._user1_tex2.createTime),
'lastModifiedTime': str(self._user1_tex2.lastModifiedTime),
'isAllowEdit': True}
],
'folders': [
{
'id': self._user1_project1_folder1.id,
'name': self._user1_project1_folder1.name,
'folders': [],
'files': [
{'id': self._user1_tex3.id,
'name': self._user1_tex3.name,
'mimetype': self._user1_tex3.mimeType,
'size': self._user1_tex3.size,
'createTime': str(self._user1_tex3.createTime),
'lastModifiedTime': str(self._user1_tex3.lastModifiedTime),
'isAllowEdit': True},
{'id': self._user1_tex4.id,
'name': self._user1_tex4.name,
'mimetype': self._user1_tex4.mimeType,
'size': self._user1_tex4.size,
'createTime': str(self._user1_tex4.createTime),
'lastModifiedTime': str(self._user1_tex4.lastModifiedTime),
'isAllowEdit': True}
]
},
{
'id': self._user1_project1_folder2.id,
'name': self._user1_project1_folder2.name,
'folders': [
{'id': self._user1_project1_folder2_subfolder1.id,
'name': self._user1_project1_folder2_subfolder1.name,
'files': [
{'id': self._user1_binary1.id,
'name': self._user1_binary1.name,
'mimetype': self._user1_binary1.mimeType,
'size': self._user1_binary1.size,
'createTime': str(self._user1_binary1.createTime),
'lastModifiedTime': str(self._user1_binary1.lastModifiedTime),
'isAllowEdit': True},
{'id': self._user1_binary2.id,
'name': self._user1_binary2.name,
'mimetype': self._user1_binary2.mimeType,
'size': self._user1_binary2.size,
'createTime': str(self._user1_binary2.createTime),
'lastModifiedTime': str(self._user1_binary2.lastModifiedTime),
'isAllowEdit': True},
{'id': self._user1_binary3.id,
'name': self._user1_binary3.name,
'mimetype': self._user1_binary3.mimeType,
'size': self._user1_binary3.size,
'createTime': str(self._user1_binary3.createTime),
'lastModifiedTime': str(self._user1_binary3.lastModifiedTime),
'isAllowEdit': True}
],
'folders': []},
],
'files': [],
}
]
}
# überprüfe die Antwort des Servers
# sollte success als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage der Datei- und Ordnerstruktur von einem Ordner welcher user2 gehört (als user1)
response = util.documentPoster(self, command='listfiles', idpara=self._user2_project1.rootFolder.id)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage der Datei- und Ordnerstruktur von einem nicht existierenden Ordner
response = util.documentPoster(self, command='listfiles', idpara=self._invalidid)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['DIRECTORYNOTEXIST']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
collaboration = Collaboration.objects.create(user=self._user1, project=self._user2_project2)
response = util.documentPoster(self, command='listfiles', idpara=self._user2_project2.rootFolder.id)
util.validateJsonFailureResponse(self, response.content, ERROR_MESSAGES['NOTENOUGHRIGHTS'])
collaboration.isConfirmed = True
collaboration.save()
maintex = self._user2_project2.rootFolder.getMainTex()
maintex.lock(self._user2)
response = util.documentPoster(self, command='listfiles', idpara=self._user2_project2.rootFolder.id)
serveranswer = {
'id': self._user2_project2.rootFolder.id,
'name': self._user2_project2.rootFolder.name,
'project': self._user2_project2.name,
'files': [ {'id': maintex.id,
'name': maintex.name,
'mimetype': maintex.mimeType,
'size': maintex.size,
'createTime': str(maintex.createTime),
'lastModifiedTime': str(maintex.lastModifiedTime),
'isAllowEdit': False}],
'folders': []
}
self.maxDiff = None
util.validateJsonSuccessResponse(self, response.content, serveranswer)
def test_createDir(self):
"""Test der createDir() Methode des folder view
Teste das Erstellen eines neuen Ordners
Testfälle:
- user1 erstellt einen neuen Ordner im rootFolder von project1 -> Erfolg
- user1 erstellt einen Unterordner in folder1 mit dem selben Namen wie folder1 -> Erfolg
- user1 erstellt einen weiteren Unterordner in folder1 mit dem selben Namen wie folder1 -> Fehler
- user1 erstellt einen Unterordner in einem Projekt von user2 -> Fehler
- user1 erstellt einen neuen Ordner mit einem Namen, der nur Leerzeichen enthält -> Fehler
- user1 erstellt einen neuen Ordner mit einem Namen, der ein leerer String ist -> Fehler
- user1 erstellt einen neuen Ordner im rootFolder von user2_sharedproject -> Erfolg
:return: None
"""
# Sende Anfrage zum Erstellen eines Ordners im rootfolder von Projekt 1
response = util.documentPoster(self, command='createdir', idpara=self._user1_project1.rootFolder.id,
name=self._newname1)
# hole das erstellte Ordner Objekt
folderobj = Folder.objects.filter(name=self._newname1, parent=self._user1_project1.rootFolder)[0]
# überprüfe ob der Ordner erstellt wurde
self.assertTrue(folderobj is not None)
# Teste, ob der Ordner im richtigen Projekt erstellt wurde
self.assertEqual(folderobj.getRoot().getProject(), self._user1_project1)
# erwartete Antwort des Servers
serveranswer = {
'id': folderobj.id,
'name': folderobj.name,
'parentid': folderobj.parent.id,
'parentname': folderobj.parent.name
}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Erstellen eines neuen Unterordners im Ordner folderobj mit dem selben Namen wie folderobj
response = util.documentPoster(self, command='createdir', idpara=folderobj.id, name=self._newname1)
# hole das erstellte Ordner Objekt
folderobj2 = Folder.objects.filter(name=self._newname1, parent=folderobj)[0]
# überprüfe ob der Ordner erstellt wurde und der Name richtig gesetzt wurde
self.assertTrue(folderobj2.name == self._newname1)
# Teste, ob der Ordner im richtigen Projekt erstellt wurde
self.assertEqual(folderobj2.getRoot().getProject(), self._user1_project1)
# erwartete Antwort des Servers
serveranswer = {
'id': folderobj2.id,
'name': self._newname1,
'parentid': folderobj2.parent.id,
'parentname': folderobj2.parent.name
}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Erstellen eines weiteren Unterordners im Ordner folderobj mit dem selben Namen wie folderobj
response = util.documentPoster(self, command='createdir', idpara=folderobj.id, name=folderobj.name.upper())
# Teste, dass das Verzeichnis auch nicht erstellt wurde (es sollte nur ein Ordner mit diesem Namen existieren)
self.assertTrue(Folder.objects.filter(name=folderobj.name, parent=folderobj).count() == 1)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['FOLDERNAMEEXISTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Erstellen eines neuen Ordners im RootFolder von user2 (als user1)
response = util.documentPoster(self, command='createdir', idpara=self._user2_project1.rootFolder.id,
name=self._newname2)
# Teste, dass das Verzeichnis auch nicht erstellt wurde
self.assertFalse(Folder.objects.filter(name=self._newname2, parent=self._user2_project1.rootFolder).exists())
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Erstellen eines neuen Ordners mit einem Namen, der nur aus Leerzeichen besteht
response = util.documentPoster(self, command='createdir', idpara=self._user1_project1.rootFolder.id,
name=self._name_only_spaces)
# Teste, dass das Verzeichnis auch nicht erstellt wurde
self.assertFalse(Folder.objects.filter(name=self._name_only_spaces,
parent=self._user1_project1.rootFolder).exists())
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Erstellen eines neuen Ordners mit einem Namen, der ein leerer String ist
response = util.documentPoster(self, command='createdir', idpara=self._user1_project1.rootFolder.id,
name=self._name_blank)
# Teste, dass das Verzeichnis auch nicht erstellt wurde
self.assertFalse(Folder.objects.filter(name=self._name_blank, parent=self._user1_project1.rootFolder).exists())
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
response = util.documentPoster(self, command='createdir', idpara=self._user2_sharedproject.rootFolder.id,
name=self._newname1)
folderobj = Folder.objects.get(name=self._newname1, parent=self._user2_sharedproject.rootFolder)
self.assertEqual(folderobj.getRoot().getProject(), self._user2_sharedproject)
serveranswer = {
'id': folderobj.id,
'name': folderobj.name,
'parentid': folderobj.parent.id,
'parentname': folderobj.parent.name
}
util.validateJsonSuccessResponse(self, response.content, serveranswer)
def test_moveDir(self):
"""Test der moveDir() Methode des folder view
Teste das Verschieben eines Ordners
Testfälle:
- user1 verschiebt einen Ordner in einen anderen Ordner -> Erfolg
- user1 verschiebt einen Ordner zwischen zwei Projekten -> Erfolg
- user1 verschiebt einen Ordner in einen Ordner der zum einem Projekt von user2 gehört -> Fehler
- user1 verschiebt einen Ordner welcher zum einem Projekt von user2 gehört -> Fehler
- user1 verschiebt einen Ordner mit einer folderID die nicht existiert -> Fehler
- user1 verschiebt einen Ordner wobei die folderID des Zielordners nicht existiert -> Fehler
- user1 verschiebt einen Ordner wobei im Zielordner bereits ein Ordner mit dem selben Namen existiert -> Fehler
(dieser Test dient der Überprüfung, ob richtig erkannt wird, dass ein Ordner mit Umlauten im Namen
bereits mit dem selben Ordner existiert, bsp. Übungs 01 -> übung 01 sollte einen Fehler liefern)
- user1 verschiebt einen Ordner in einen anderen Ordner aus user2_sharedproject -> Erfolg
:return: None
"""
# Sende Anfrage zum verschieben des folder1 in den folder2
response = util.documentPoster(self, command='movedir', idpara=self._user1_project1_folder1.id,
idpara2=self._user1_project1_folder2.id)
# folder2 sollte nun der neuen parentfolder sein
self.assertEqual(Folder.objects.get(id=self._user1_project1_folder1.id).parent, self._user1_project1_folder2)
# erwartete Antwort des Servers
serveranswer = {'id': self._user1_project1_folder1.id,
'name': self._user1_project1_folder1.name,
'parentid': self._user1_project1_folder2.id,
'parentname': self._user1_project1_folder2.name,
'rootid': self._user1_project1_folder1.root.id}
# überprüfe die Antwort des Servers
# sollte success als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Verschieben von einem Ordner zu einem anderen Projekt
response = util.documentPoster(self, command='movedir', idpara=self._user1_project1_folder2.id,
idpara2=self._user1_project2.rootFolder.id)
folderobj = Folder.objects.get(id=self._user1_project1_folder2.id)
# der Ordner sollte nun project2.rootFolder als parent und neuen rootFolder haben
self.assertEqual(folderobj.parent, self._user1_project2.rootFolder)
self.assertEqual(folderobj.getRoot(), self._user1_project2.rootFolder)
# erwartete Antwort des Servers
serveranswer = {'id': self._user1_project1_folder2.id,
'name': self._user1_project1_folder2.name,
'parentid': self._user1_project2.rootFolder.id,
'parentname': self._user1_project2.rootFolder.name,
'rootid': self._user1_project2.rootFolder.id}
# überprüfe die Antwort des Servers
# sollte success als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Verschieben eines Ordners in einen Ordner der zum einem Projekt von user2 gehört
response = util.documentPoster(self, command='movedir', idpara=self._user1_project1_folder2.id,
idpara2=self._user2_project1.rootFolder.id)
# der parentFolder sollte nicht user2_project1.rootFolder sein
self.assertNotEqual(Folder.objects.get(id=self._user1_project1_folder2.id).parent,
self._user2_project1.rootFolder)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Verschieben eines Ordners der user1 nicht gehört
response = util.documentPoster(self, command='movedir', idpara=self._user2_project1_folder1.id,
idpara2=self._user1_project1_folder1.id)
# der parentFolder sollte nicht user1_project1_folder1 sein
self.assertNotEqual(Folder.objects.get(id=self._user2_project1_folder1.id).parent, self._user1_project1_folder1)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Anzahl der Ordner welche folder2 als parentFolder haben
old_parent_count = Folder.objects.filter(parent=self._user1_project1_folder2).count()
# Sende Anfrage zum Verschieben eines Ordners mit einer ungültigen ID
response = util.documentPoster(self, command='movedir', idpara=self._invalidid,
idpara2=self._user1_project1_folder2.id)
# es sollte kein weiterer Ordner folder2 nun als parent besitzen
self.assertEqual(Folder.objects.filter(parent=self._user1_project1_folder2).count(), old_parent_count)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['DIRECTORYNOTEXIST']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Verschieben eines Ordners, wobei im Zielordner bereits ein Ordner mit selben Namen existiert
# Testet ob die Überprüfung auf Ordner mit dem selben Namen richtig funktioniert, wobei im Namen Umlaute sind
# wird nur ausgeführt wenn keine SQLITE Datenbank benutzt wird, da dies sonst nicht unterstützt wird
if not util.isSQLiteDatabse():
response = util.documentPoster(self, command='movedir', idpara=self._user1_project4_folder3.id,
idpara2=self._user1_project4_folder1.id)
# der parentFolder sollte nicht user1_project4_folder1 sein
self.assertNotEqual(Folder.objects.get(id=self._user1_project4_folder3.id).parent,
self._user1_project4_folder1)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['FOLDERNAMEEXISTS']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# response sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
response = util.documentPoster(self, command='movedir', idpara=self._user2_sharedproject_folder1.id,
idpara2=self._user2_sharedproject_folder2.id)
self.assertEqual(Folder.objects.get(pk=self._user2_sharedproject_folder1.id).parent, self._user2_sharedproject_folder2)
serveranswer = {'id': self._user2_sharedproject_folder1.id,
'name': self._user2_sharedproject_folder1.name,
'parentid': self._user2_sharedproject_folder2.id,
'parentname': self._user2_sharedproject_folder2.name,
'rootid': self._user2_sharedproject_folder1.root.id}
util.validateJsonSuccessResponse(self, response.content, serveranswer)
def test_renameDir(self):
"""Test der renameDir() Methode des folder view
Teste das Umbenennen eines Ordners
Testfälle:
- user1 benennt einen Ordner um -> Erfolg
- user1 benennt einen Ordner um mit einem Namen der bereits im selben Verzeichnis existiert -> Fehler
- user1 benennt einen Ordner um der user2 gehört -> Fehler
- user1 benennt einen Ordner um mit einem Namen der nur aus Leerzeichen besteht -> Fehler
- user1 benennt einen Ordner um mit einem Namen der ein leerer String ist -> Fehler
- user1 benennt einen Ordner um mit einem Namen der ungültige Zeichen enthält -> Fehler
- user1 benennt einen Ordner aus user2_sharedproject um -> Erfolg
:return: None
"""
oldid = self._user1_project1_folder1.id
# Sende Anfrage zum Umbenennen eines Ordners
response = util.documentPoster(self, command='renamedir', idpara=self._user1_project1_folder1.id,
name=self._newname1)
# der Ordner sollte in der Datenbank den neuen Namen besitzen
self.assertEqual(Folder.objects.get(id=self._user1_project1_folder1.id).name, self._newname1)
# erwartete Antwort des Servers
serveranswer = {
'id': self._user1_project1_folder1.id,
'name': self._newname1
}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Umbenennen eines Ordners mit einem Namen der bereits im selben Verzeichnis existiert
response = util.documentPoster(self, command='renamedir', idpara=self._user1_project1_folder2.id,
name=self._newname1)
# der Name des Ordners sollte nicht zu newname1 geändert worden sein
self.assertNotEqual(Folder.objects.get(id=self._user1_project1_folder2.id).name, self._newname1)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['FOLDERNAMEEXISTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Umbenenne eines Ordners von einem Projekt das user2 gehört
response = util.documentPoster(self, command='renamedir', idpara=self._user2_project1_folder1.id,
name=self._newname2)
# der Name des Ordners sollte nicht zu newname2 geändert worden sein
self.assertNotEqual(Folder.objects.get(id=self._user2_project1_folder1.id).name, self._newname2)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Umbenenne eines Ordners mit einem Namen der nur aus Leerzeichen besteht
response = util.documentPoster(self, command='renamedir', idpara=self._user1_project1_folder2.id,
name=self._name_only_spaces)
# der Name des Ordners sollte nicht zu name_only_spaces geändert worden sein
self.assertNotEqual(Folder.objects.get(id=self._user1_project1_folder2.id).name, self._name_only_spaces)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Umbenenne eines Ordners mit einem Namen der ein leerer String ist
response = util.documentPoster(self, command='renamedir', idpara=self._user1_project1_folder2.id,
name=self._name_blank)
# der Name des Ordners sollte nicht zu name_blank geändert worden sein
self.assertNotEqual(Folder.objects.get(id=self._user1_project1_folder2.id).name, self._name_blank)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Umbenenne eines Ordners mit einem Namen der ungültige Sonderzeichen enthält
response = util.documentPoster(self, command='renamedir', idpara=self._user1_project1_folder2.id,
name=self._name_invalid_chars)
# der Name des Ordners sollte nicht zu name_invalid_chars geändert worden sein
self.assertNotEqual(Folder.objects.get(id=self._user1_project1_folder2.id).name, self._name_invalid_chars)
serveranswer = ERROR_MESSAGES['INVALIDNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# user1 benennt einen Ordner aus user2_sharedproject um
response = util.documentPoster(self, command='renamedir', idpara=self._user2_sharedproject_folder1.id,
name=self._newname1)
self.assertEqual(Folder.objects.get(pk=self._user2_sharedproject_folder1.id).name, self._newname1)
serveranswer = {
'id': self._user2_sharedproject_folder1.id,
'name': self._newname1
}
util.validateJsonSuccessResponse(self, response.content, serveranswer)
def test_rmDir(self):
"""Test der rmDir() Methode des folder view
Teste das Löschen eines Ordners
Testfälle:
- user1 löscht einen Ordner eines Projektes -> Erfolg
- user1 löscht Ordner mit einer folderID welche nicht existiert -> Fehler
- user1 löscht rootFolder eines Projektes -> Fehler
- user1 löscht Ordner eines Projektes welches user2 gehört -> Fehler
- user1 löscht einen Ordner aus user2_sharedproject -> Erfolg
- user1 löscht einen gesperrten (von user2) Ordner -> Fehler
- user1 löscht einen gesperrten (von sich selbst) Ordner -> Erfolg
:return: None
"""
oldrootfolderid = self._user1_project1.rootFolder.id
oldtodeletefolder = self._user1_project1_folder2
oldsubdeletefolder = self._user1_project1_folder2_subfolder1
oldfileid = self._user1_binary1.id
# Stelle sicher, dass zu diesem Zeitpunkt der rootordner von project1 noch existiert
self.assertTrue(Folder.objects.filter(id=oldrootfolderid).exists())
# Stelle sicher, dass es zu diesem Projekt mind. ein Unterverzeichnis existiert + mind. eine Datei
self.assertEqual(self._user1_project1_folder1.parent, self._user1_project1.rootFolder)
self.assertTrue(File.objects.filter(id=oldfileid).exists())
# Sende Anfrage zum Löschen eines Ordners
response = util.documentPoster(self, command='rmdir', idpara=self._user1_project1_folder2.id)
# Ordner sollte nicht mehr in der Datenbank vorhanden sein
self.assertFalse(Folder.objects.filter(id=oldtodeletefolder.id).exists())
# Unterverzeichnisse und Dateien sollten dabei auch gelöscht werden!
self.assertFalse(Folder.objects.filter(id=oldsubdeletefolder.id).exists())
# Files von Unterverzeichnissen ebenso
self.assertFalse(File.objects.filter(id=oldfileid).exists())
# erwartete Antwort des Servers
serveranswer = {}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Löschen eines Ordners mit einer folderID welche nicht existiert
response = util.documentPoster(self, command='rmdir', idpara=self._invalidid)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['DIRECTORYNOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Löschen eines RootFolders von einem Projekt
response = util.documentPoster(self, command='rmdir', idpara=self._user1_project1.rootFolder.id)
# der rootFolder sollte noch existieren
self.assertTrue(Folder.objects.filter(id=self._user1_project1.rootFolder.id).exists())
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Löschen eines Ordners von einem Projekt welches user2 gehört (als user1)
response = util.documentPoster(self, command='rmdir', idpara=self._user2_project1_folder1.id)
# user2_project1_folder1 sollte noch existieren
self.assertTrue(Folder.objects.filter(id=self._user2_project1_folder1.id).exists())
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# user1 löscht einen Ordner aus user2_sharedproject
response = util.documentPoster(self, command='rmdir', idpara=self._user2_sharedproject_folder2.id)
util.validateJsonSuccessResponse(self, response.content, {})
self.assertFalse(Folder.objects.filter(id=self._user2_sharedproject_folder2.id).exists())
# user1 löscht einen gesperrten (von user2) Ordner
self._user2_sharedproject_folder1_texfile.lock(self._user2)
response = util.documentPoster(self, command='rmdir', idpara=self._user2_sharedproject_folder1.id)
util.validateJsonFailureResponse(self, response.content, ERROR_MESSAGES['DIRLOCKED'])
self.assertTrue(Folder.objects.filter(id=self._user2_sharedproject_folder1.id).exists())
# user1 löscht einen gesperrten (von sich selbst) Ordner
self._user2_sharedproject_folder1_texfile.unlock()
self._user2_sharedproject_folder1_texfile.lock(self._user1)
response = util.documentPoster(self, command='rmdir', idpara=self._user2_sharedproject_folder1.id)
util.validateJsonSuccessResponse(self, response.content, {})
self.assertFalse(Folder.objects.filter(id=self._user2_sharedproject_folder1.id).exists())
def test_project2Template(self):
"""Test der project2Template() Methode aus dem template view.
Teste das konvertieren eines Projektes von einem Benutzer in eine Vorlage.
Testfälle:
- user1 konvertiert ein Projekt in ein Template -> Erfolg
- user1 konvertiert ein Projekt in ein Template mit existierendem Namen
-> Erfolg (Name der erzeugten Vorlage mit Suffix '(2)')
- user1 konvertiert ein Projekt in ein Template mit erneut dem Namen des vorherigen Testfalls
-> Erfolg (Name der erzeugten Vorlage mit Suffix '(3)')
- user1 versucht ein Template mit Illegalen Zeichen zu erstellen -> Fehler
- user1 versucht ein Template in ein Template zu verwandeln -> Fehler
- user1 konvertiert ein freigegebenes Projekt
(Einladung ist nicht bestätigt) in ein Template -> Fehler
- user1 konvertiert ein freigegebenes Projekt
(Einladung ist bestätigt) in ein Template -> Erfolg
:return: None
"""
# Sende Anfrage zum konvertieren eines vorhandenen Projektes in eine Vorlage
response = util.documentPoster(
self, command='project2template', idpara=self._user1_project1.id, name=self._newname1)
templateobj = ProjectTemplate.objects.get(name=self._newname1, author=self._user1)
# erwartete Antwort des Servers
serveranswer = {'id': templateobj.id, 'name': self._newname1}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren eines vorhandenen Projektes in eine Vorlage mit bereits existierendem Namen
response = util.documentPoster(self, command='project2template',
idpara=self._user1_project1.id, name=self._newname1)
# erwartete Antwort des Servers
serveranswer = {'id': ProjectTemplate.objects.get(author=self._user1,
name=DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM)).id,
'name': DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM)}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren eines vorhandenen Projektes in eine Vorlage mit erneut dem Namen des vorherigen Testfalls
response = util.documentPoster(self, command='project2template',
idpara=self._user1_project1.id, name=self._newname1)
# erwartete Antwort des Servers
serveranswer = {'id': ProjectTemplate.objects.get(author=self._user1,
name=DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM+1)).id,
'name': DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM+1)}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, auf Namen mit illegalen Zeichen
response = util.documentPoster(self, command='project2template', idpara=self._user1_project1.id, name='<>')
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['INVALIDNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, ob man auch ein template in ein Template verwandeln kann
# (sollte eine Fehlermeldung geben)
response = util.documentPoster(self, command='project2template',
idpara=self._user1_template1.id, name=self._newname2)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['PROJECTNOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
collaboration = Collaboration.objects.create(project=self._user2_project1, user=self._user1)
response = util.documentPoster(self, command='project2template', idpara=self._user2_project1.id, name=self._newname5)
util.validateJsonFailureResponse(self, response.content, ERROR_MESSAGES['NOTENOUGHRIGHTS'])
# --------------------------------------------------------------------------------------------------------------
collaboration.isConfirmed = True
collaboration.save()
response = util.documentPoster(self, command='project2template', idpara=self._user2_project1.id, name=self._newname5)
templateobj = ProjectTemplate.objects.get(name=self._newname5, author=self._user1)
util.validateJsonSuccessResponse(self, response.content, {'id': templateobj.id, 'name': self._newname5})
def test_templateRename(self):
"""Test der templateRename() Methode aus dem project view
Teste das Umbenennen einer Vorlage von einem Benutzer.
Testfälle:
- user1 benennt eine Vorlage um -> Erfolg
- user1 benennt eine Vorlage um mit einem Namen, der nur Leerzeichen enthält -> Fehler
- user1 benennt eine Vorlage um mit einem Namen, der nur ein leerer String ist -> Fehler
- user1 benennt eine Vorlage um mit einem Namen, der ungültige Sonderzeichen enthält -> Fehler
- user1 benennt eine Vorlage um mit einem Namen, der bereits existiert -> Fehler
- user1 benennt eine Vorlage mit einer ungültigen projectid um -> Fehler
- user1 benennt eine Vorlage von user2 um -> Fehler
:return: None
"""
# Sende Anfrage zum umbenennen einer Vorlage
response = util.documentPoster(self, command='templaterename', idpara=self._user1_template1.id,
name=self._newname1)
# der neue Vorlagenname sollte in der Datenbank nun geändert worden sein
self.assertEqual(ProjectTemplate.objects.get(id=self._user1_template1.id).name, self._newname1)
# erwartete Antwort des Servers
serveranswer = {'id': self._user1_template1.id, 'name': self._newname1}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit dictionary übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der nur Leerzeichen enthält
response = util.documentPoster(self, command='templaterename', idpara=self._user1_template2.id,
name=self._name_only_spaces)
# der Name der Vorlage sollte nicht mit name_only_spaces übereinstimmen
self.assertNotEqual(ProjectTemplate.objects.get(id=self._user1_template2.id).name, self._name_only_spaces)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der ein leerer String ist
response = util.documentPoster(self, command='templaterename', idpara=self._user1_template2.id,
name=self._name_blank)
# der Name der Vorlage sollte nicht mit name_blank übereinstimmen
self.assertNotEqual(ProjectTemplate.objects.get(id=self._user1_template2.id).name, self._name_blank)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der ungültige Sonderzeichen enthält
response = util.documentPoster(self, command='templaterename', idpara=self._user1_template2.id,
name=self._name_invalid_chars)
# der Name der Vorlage sollte nicht mit name_invalid_chars übereinstimmen
self.assertNotEqual(ProjectTemplate.objects.get(id=self._user1_template2.id).name, self._name_invalid_chars)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['INVALIDNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der bereits existiert
response = util.documentPoster(self, command='templaterename', idpara=self._user1_template3.id,
name=self._user1_template2.name.upper())
# der Name der Vorlage sollte nicht mit template2.name.upper() übereinstimmen
self.assertNotEqual(ProjectTemplate.objects.get(id=self._user1_template3.id).name,
self._user1_template2.name.upper())
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['TEMPLATEALREADYEXISTS'] % self._user1_template2.name.upper()
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einer ungültigen template
response = util.documentPoster(self, command='templaterename', idpara=self._invalidid,
name=self._newname2)
# es sollte keine Vorlage mit dem Namen newname2 vorhanden sein
self.assertTrue(ProjectTemplate.objects.filter(name=self._newname2, author=self._user1).count() == 0)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['TEMPLATENOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einer templateid, welche user2 gehört
response = util.documentPoster(self, command='templaterename', idpara=self._user2_template1.id,
name=self._newname3)
# der Name der Vorlage sollte nicht mit newname3 übereinstimmen
self.assertNotEqual(ProjectTemplate.objects.get(id=self._user2_template1.id).name, self._newname3)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
def test_latexCompile(self):
"""Test der latexCompile() Methode des file view
Teste das Kompilieren einer einfachen .tex Datei,
(Hier soll nur der generelle Aufruf der latexCompile() Funktion getestet werden,
weitere Tests für die eigentliche compile Funktion befinden sich in test_compile.py)
Testfälle:
- user1 kompiliert eine simple .tex Datei -> Erfolg
- user1 kompiliert eine fehlerhafte .tex Datei -> Fehler
- user1 kompiliert eine Datei die nicht vorhanden ist -> Fehler
- user1 kompiliert eine Datei welche user2 gehört -> Fehler
:return: None
"""
# erstelle ein Projekt mit 2 .tex Dateien, wobei texobj2 keine gültige .tex Datei ist
projectobj = Project.objects.createWithMainTex(name=self._newname1,
author=self._user1)
src_code = "\\documentclass[a4paper,10pt]{article} \\usepackage[utf8]{inputenc} \\title{test} " \
"\\begin{document} \\maketitle \\begin{abstract} \\end{abstract} \\section{} \\end{document}"
texobj1 = TexFile.objects.create(name=self._newtex_name1,
folder=projectobj.rootFolder,
source_code=src_code)
texobj2 = TexFile.objects.create(name=self._newtex_name2,
folder=projectobj.rootFolder,
source_code='Test')
# Sende Anfrage zum Kompilieren der .tex Datei
response = util.documentPoster(self,
command='compile',
idpara=texobj1.id,
idpara3=0,
idpara4=0,
idpara5=0)
# der Name sollte dem der .tex Datei entsprechen, jedoch mit der Endung .pdf
pdf_name = texobj1.name[:-3] + 'pdf'
# hole das PDF Objekt
pdfobj = PDF.objects.filter(name=pdf_name, folder=texobj1.folder)
# Das PDF Objekt zu der .tex Datei sollte in der Datenbank vorhanden sein
self.assertTrue(pdfobj.count() == 1)
# erwartete Antwort des Servers
serveranswer = {'id': pdfobj[0].id, 'name': pdf_name}
# überprüfe die Antwort des Servers
# sollte success als status liefern
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Kompilieren einer fehlerhaften .tex Datei
response = util.documentPoster(self,
command='compile',
idpara=texobj2.id,
idpara3=0,
idpara4=0,
idpara5=0)
# erwartete Antwort des Servers
serveranswer = {
'error':
'["Syntax-Fehler: Es konnte kein g\\u00fcltiges \\\\end gefunden werden."]'
}
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Kompilieren einer Datei die nicht vorhanden ist
response = util.documentPoster(self,
command='compile',
idpara=self._invalidid,
idpara3=0,
idpara4=0,
idpara5=0)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['FILENOTEXIST']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Kompilieren einer Datei die user2 gehört (als user1)
response = util.documentPoster(self,
command='compile',
idpara=self._user2_tex1.id,
idpara3=0,
idpara4=0,
idpara5=0)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# sollte failure als status liefern
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
src_code = "\\documentclass[a4paper,10pt]{article} \\usepackage[utf8]{inputenc} \\title{test} " \
"\\begin{document} \\maketitle \\begin{abstract} \\end{abstract} \\section{} \\end{document}"
texobj = TexFile.objects.create(
name=self._newtex_name1,
folder=self._user2_sharedproject.rootFolder,
source_code=src_code)
response = util.documentPoster(self,
command='compile',
idpara=texobj.id,
idpara3=0,
idpara4=0,
idpara5=0)
pdf_name = texobj.name[:-3] + 'pdf'
pdfobj = PDF.objects.filter(name=pdf_name, folder=texobj.folder)
self.assertTrue(pdfobj.count() == 1)
util.validateJsonSuccessResponse(self, response.content, {
'id': pdfobj[0].id,
'name': pdf_name
})
def test_template2Project(self):
"""Test der template2Project() Methode aus dem template view.
Teste das konvertieren einer Vorlage von einem Benutzer in ein Projekt.
Testfälle:
- user1 konvertiert ein Template in ein Projekt -> Erfolg
- user1 konvertiert ein Template in ein Projekt mit existierendem Namen
-> Erfolg (Name des erzeugten Projektes mit Suffix '(2)')
- user1 konvertiert eine Vorlage in ein Projekt mit erneut dem Namen des vorherigen Testfalls
-> Erfolg (Name des erzeugten Projektes mit Suffix '(3)')
- user1 versucht ein Projekt mit Illegalen Zeichen zu erstellen -> Fehler
- user1 versucht ein Projekt in ein Projekt zu verwandeln -> Fehler
:return: None
"""
# Sende Anfrage zum konvertieren einer Vorlage in ein Projekt
response = util.documentPoster(self, command='template2project', idpara=self._user1_template1.id,
name=self._newname1)
projectobj = Project.objects.filter(name=self._newname1, author=self._user1)[0]
# erwartete Antwort des Servers
serveranswer = {'id': projectobj.id, 'name': self._newname1, 'rootid': projectobj.rootFolder.id}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren einer Vorlage in ein Projekt mit bereits existierendem Namen
response = util.documentPoster(self, command='template2project',
idpara=self._user1_template1.id, name=self._newname1)
projectobj = Project.objects.get(author=self._user1,
name=DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM))
# erwartete Antwort des Servers
serveranswer = {'id': projectobj.id,
'name': DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM),
'rootid': projectobj.rootFolder.id}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren einer Vorlage in ein Projekt mit erneut dem Namen des vorherigen Testfalls
response = util.documentPoster(self, command='template2project',
idpara=self._user1_template1.id, name=self._newname1)
projectobj = Project.objects.get(author=self._user1,
name=DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM+1))
# erwartete Antwort des Servers
serveranswer = {'id': projectobj.id,
'name': DUPLICATE_NAMING_REGEX % (self._newname1,DUPLICATE_INIT_SUFFIX_NUM+1),
'rootid': projectobj.rootFolder.id}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, auf Namen mit illegalen Zeichen
response = util.documentPoster(self, command='template2project', idpara=self._user1_template1.id, name='<>')
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['INVALIDNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, ob man auch ein Projekt in ein Projekt verwandeln kann
# (sollte eine Fehlermeldung geben)
response = util.documentPoster(self, command='template2project', idpara=self._user1_project1.id,
name=self._newname2)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['TEMPLATENOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
def test_listtemplates(self):
"""Test der listtemplates() Methode aus dem template view.
Teste das Auflisten von Vorlagen eines Benutzers
Testfälle:
- user1 fordert eine Liste aller Vorlagen an -> Erfolg
:returns: None
"""
# Sende Anfrage zum Auflisten aller Vorlagen
response = util.documentPoster(self, command='listtemplates')
# erwartete Antwort des Servers
serveranswer = [
{
"ownername":
self._user1_template1.author.username,
"rootid":
self._user1_template1.rootFolder.id,
"id":
self._user1_template1.id,
"createtime":
util.datetimeToString(self._user1_template1.createTime),
"ownerid":
self._user1_template1.author.id,
"name":
self._user1_template1.name,
},
{
"ownername":
self._user1_template2.author.username,
"rootid":
self._user1_template2.rootFolder.id,
"id":
self._user1_template2.id,
"createtime":
util.datetimeToString(self._user1_template2.createTime),
"ownerid":
self._user1_template2.author.id,
"name":
self._user1_template2.name,
},
{
"ownername":
self._user1_template3.author.username,
"rootid":
self._user1_template3.rootFolder.id,
"id":
self._user1_template3.id,
"createtime":
util.datetimeToString(self._user1_template3.createTime),
"ownerid":
self._user1_template3.author.id,
"name":
self._user1_template3.name,
},
]
# überprüfe die Antwort des Servers
# status sollte success sein
# teste, ob in response die beiden erstellten Vorlagen von user1 richtig aufgelistet werden
# und keine Vorlagen von user2 aufgelistet werden
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
def test_project2Template(self):
"""Test der project2Template() Methode aus dem template view.
Teste das konvertieren eines Projektes von einem Benutzer in eine Vorlage.
Testfälle:
- user1 konvertiert ein Projekt in ein Template -> Erfolg
- user1 konvertiert ein Projekt in ein Template mit existierendem Namen
-> Erfolg (Name der erzeugten Vorlage mit Suffix '(2)')
- user1 konvertiert ein Projekt in ein Template mit erneut dem Namen des vorherigen Testfalls
-> Erfolg (Name der erzeugten Vorlage mit Suffix '(3)')
- user1 versucht ein Template mit Illegalen Zeichen zu erstellen -> Fehler
- user1 versucht ein Template in ein Template zu verwandeln -> Fehler
- user1 konvertiert ein freigegebenes Projekt
(Einladung ist nicht bestätigt) in ein Template -> Fehler
- user1 konvertiert ein freigegebenes Projekt
(Einladung ist bestätigt) in ein Template -> Erfolg
:return: None
"""
# Sende Anfrage zum konvertieren eines vorhandenen Projektes in eine Vorlage
response = util.documentPoster(self,
command='project2template',
idpara=self._user1_project1.id,
name=self._newname1)
templateobj = ProjectTemplate.objects.get(name=self._newname1,
author=self._user1)
# erwartete Antwort des Servers
serveranswer = {'id': templateobj.id, 'name': self._newname1}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren eines vorhandenen Projektes in eine Vorlage mit bereits existierendem Namen
response = util.documentPoster(self,
command='project2template',
idpara=self._user1_project1.id,
name=self._newname1)
# erwartete Antwort des Servers
serveranswer = {
'id':
ProjectTemplate.objects.get(
author=self._user1,
name=DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM)).id,
'name':
DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM)
}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren eines vorhandenen Projektes in eine Vorlage mit erneut dem Namen des vorherigen Testfalls
response = util.documentPoster(self,
command='project2template',
idpara=self._user1_project1.id,
name=self._newname1)
# erwartete Antwort des Servers
serveranswer = {
'id':
ProjectTemplate.objects.get(
author=self._user1,
name=DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM + 1)).id,
'name':
DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM + 1)
}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, auf Namen mit illegalen Zeichen
response = util.documentPoster(self,
command='project2template',
idpara=self._user1_project1.id,
name='<>')
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['INVALIDNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, ob man auch ein template in ein Template verwandeln kann
# (sollte eine Fehlermeldung geben)
response = util.documentPoster(self,
command='project2template',
idpara=self._user1_template1.id,
name=self._newname2)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['PROJECTNOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
collaboration = Collaboration.objects.create(
project=self._user2_project1, user=self._user1)
response = util.documentPoster(self,
command='project2template',
idpara=self._user2_project1.id,
name=self._newname5)
util.validateJsonFailureResponse(self, response.content,
ERROR_MESSAGES['NOTENOUGHRIGHTS'])
# --------------------------------------------------------------------------------------------------------------
collaboration.isConfirmed = True
collaboration.save()
response = util.documentPoster(self,
command='project2template',
idpara=self._user2_project1.id,
name=self._newname5)
templateobj = ProjectTemplate.objects.get(name=self._newname5,
author=self._user1)
util.validateJsonSuccessResponse(self, response.content, {
'id': templateobj.id,
'name': self._newname5
})
def test_templateRename(self):
"""Test der templateRename() Methode aus dem project view
Teste das Umbenennen einer Vorlage von einem Benutzer.
Testfälle:
- user1 benennt eine Vorlage um -> Erfolg
- user1 benennt eine Vorlage um mit einem Namen, der nur Leerzeichen enthält -> Fehler
- user1 benennt eine Vorlage um mit einem Namen, der nur ein leerer String ist -> Fehler
- user1 benennt eine Vorlage um mit einem Namen, der ungültige Sonderzeichen enthält -> Fehler
- user1 benennt eine Vorlage um mit einem Namen, der bereits existiert -> Fehler
- user1 benennt eine Vorlage mit einer ungültigen projectid um -> Fehler
- user1 benennt eine Vorlage von user2 um -> Fehler
:return: None
"""
# Sende Anfrage zum umbenennen einer Vorlage
response = util.documentPoster(self,
command='templaterename',
idpara=self._user1_template1.id,
name=self._newname1)
# der neue Vorlagenname sollte in der Datenbank nun geändert worden sein
self.assertEqual(
ProjectTemplate.objects.get(id=self._user1_template1.id).name,
self._newname1)
# erwartete Antwort des Servers
serveranswer = {'id': self._user1_template1.id, 'name': self._newname1}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit dictionary übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der nur Leerzeichen enthält
response = util.documentPoster(self,
command='templaterename',
idpara=self._user1_template2.id,
name=self._name_only_spaces)
# der Name der Vorlage sollte nicht mit name_only_spaces übereinstimmen
self.assertNotEqual(
ProjectTemplate.objects.get(id=self._user1_template2.id).name,
self._name_only_spaces)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der ein leerer String ist
response = util.documentPoster(self,
command='templaterename',
idpara=self._user1_template2.id,
name=self._name_blank)
# der Name der Vorlage sollte nicht mit name_blank übereinstimmen
self.assertNotEqual(
ProjectTemplate.objects.get(id=self._user1_template2.id).name,
self._name_blank)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['BLANKNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der ungültige Sonderzeichen enthält
response = util.documentPoster(self,
command='templaterename',
idpara=self._user1_template2.id,
name=self._name_invalid_chars)
# der Name der Vorlage sollte nicht mit name_invalid_chars übereinstimmen
self.assertNotEqual(
ProjectTemplate.objects.get(id=self._user1_template2.id).name,
self._name_invalid_chars)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['INVALIDNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einem Namen der bereits existiert
response = util.documentPoster(self,
command='templaterename',
idpara=self._user1_template3.id,
name=self._user1_template2.name.upper())
# der Name der Vorlage sollte nicht mit template2.name.upper() übereinstimmen
self.assertNotEqual(
ProjectTemplate.objects.get(id=self._user1_template3.id).name,
self._user1_template2.name.upper())
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES[
'TEMPLATEALREADYEXISTS'] % self._user1_template2.name.upper()
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einer ungültigen template
response = util.documentPoster(self,
command='templaterename',
idpara=self._invalidid,
name=self._newname2)
# es sollte keine Vorlage mit dem Namen newname2 vorhanden sein
self.assertTrue(
ProjectTemplate.objects.filter(name=self._newname2,
author=self._user1).count() == 0)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['TEMPLATENOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum umbenennen einer Vorlage mit einer templateid, welche user2 gehört
response = util.documentPoster(self,
command='templaterename',
idpara=self._user2_template1.id,
name=self._newname3)
# der Name der Vorlage sollte nicht mit newname3 übereinstimmen
self.assertNotEqual(
ProjectTemplate.objects.get(id=self._user2_template1.id).name,
self._newname3)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
def test_templateRm(self):
"""Test der templateRm() Methode aus dem template view
Teste das Löschen einer Vorlage von einem Benutzer.
Testfälle:
- user1 löscht eine vorhandene Vorlage -> Erfolg
- user1 löscht eine nicht vorhandene Vorlage -> Fehler
- user1 löscht eine Vorlage welche user2 gehört -> Fehler
:return: None
"""
# Sende Anfrage zum Löschen einer vorhandenen Vorlage
response = util.documentPoster(self,
command='templaterm',
idpara=self._user1_template1.id)
# es sollten keine Ordner der Vorlage mehr in der Datenbank existieren
self.assertFalse(
Folder.objects.filter(id=self._user1_template1_folder1.id))
self.assertFalse(
Folder.objects.filter(
id=self._user1_template1_folder2_subfolder1.id))
# erwartete Antwort des Servers
serveranswer = {}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Löschen eines nicht vorhandenen Projektes
response = util.documentPoster(self,
command='templaterm',
idpara=self._invalidid)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['TEMPLATENOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum Löschen eines Projektes von user2 (als user1)
response = util.documentPoster(self,
command='templaterm',
idpara=self._user2_template1.id)
# das Projekt sollte nicht gelöscht worden sein
self.assertTrue(
ProjectTemplate.objects.get(id=self._user2_template1.id))
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['NOTENOUGHRIGHTS']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
def test_template2Project(self):
"""Test der template2Project() Methode aus dem template view.
Teste das konvertieren einer Vorlage von einem Benutzer in ein Projekt.
Testfälle:
- user1 konvertiert ein Template in ein Projekt -> Erfolg
- user1 konvertiert ein Template in ein Projekt mit existierendem Namen
-> Erfolg (Name des erzeugten Projektes mit Suffix '(2)')
- user1 konvertiert eine Vorlage in ein Projekt mit erneut dem Namen des vorherigen Testfalls
-> Erfolg (Name des erzeugten Projektes mit Suffix '(3)')
- user1 versucht ein Projekt mit Illegalen Zeichen zu erstellen -> Fehler
- user1 versucht ein Projekt in ein Projekt zu verwandeln -> Fehler
:return: None
"""
# Sende Anfrage zum konvertieren einer Vorlage in ein Projekt
response = util.documentPoster(self,
command='template2project',
idpara=self._user1_template1.id,
name=self._newname1)
projectobj = Project.objects.filter(name=self._newname1,
author=self._user1)[0]
# erwartete Antwort des Servers
serveranswer = {
'id': projectobj.id,
'name': self._newname1,
'rootid': projectobj.rootFolder.id
}
# überprüfe die Antwort des Servers
# status sollte success sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren einer Vorlage in ein Projekt mit bereits existierendem Namen
response = util.documentPoster(self,
command='template2project',
idpara=self._user1_template1.id,
name=self._newname1)
projectobj = Project.objects.get(
author=self._user1,
name=DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM))
# erwartete Antwort des Servers
serveranswer = {
'id':
projectobj.id,
'name':
DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM),
'rootid':
projectobj.rootFolder.id
}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Sende Anfrage zum konvertieren einer Vorlage in ein Projekt mit erneut dem Namen des vorherigen Testfalls
response = util.documentPoster(self,
command='template2project',
idpara=self._user1_template1.id,
name=self._newname1)
projectobj = Project.objects.get(
author=self._user1,
name=DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM + 1))
# erwartete Antwort des Servers
serveranswer = {
'id':
projectobj.id,
'name':
DUPLICATE_NAMING_REGEX %
(self._newname1, DUPLICATE_INIT_SUFFIX_NUM + 1),
'rootid':
projectobj.rootFolder.id
}
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonSuccessResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, auf Namen mit illegalen Zeichen
response = util.documentPoster(self,
command='template2project',
idpara=self._user1_template1.id,
name='<>')
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['INVALIDNAME']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)
# --------------------------------------------------------------------------------------------------------------
# Teste, ob man auch ein Projekt in ein Projekt verwandeln kann
# (sollte eine Fehlermeldung geben)
response = util.documentPoster(self,
command='template2project',
idpara=self._user1_project1.id,
name=self._newname2)
# erwartete Antwort des Servers
serveranswer = ERROR_MESSAGES['TEMPLATENOTEXIST']
# überprüfe die Antwort des Servers
# status sollte failure sein
# die Antwort des Servers sollte mit serveranswer übereinstimmen
util.validateJsonFailureResponse(self, response.content, serveranswer)