def test_moveDir2(self): """Test2 der moveDir() Methode des folder view Teste das Verschieben eines Ordners Testfälle: - user1 verschiebt einen Ordner, wobei im Zielordner ein gleichnamiges Verzeichnis existiert -> Fehler :return: None """ # Benenne subfolder so um, dass er den gleichen Namen, wie parentfolder self._user1_project1_folder2_subfolder1.name = self._user1_project1_folder2.name self._user1_project1_folder2_subfolder1.save() # Versuche subfolder in den gleichen Ordner wie parentfolder zu verschieben response = util.documentPoster(self, command='movedir', idpara=self._user1_project1_folder2_subfolder1.id, idpara2=self._user1_project1_folder2.parent.id) # subfolder1 sollte nicht den selben übergeordnerten Ordner wie folder2 haben self.assertNotEqual(Folder.objects.get(id=self._user1_project1_folder2_subfolder1.id).parent, self._user1_project1_folder2.parent) # 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)
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_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_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_Execute(self): """Test der execute() Methode des document view Teste die Verteilfunktion, die die verschiedenen Document-commands den richtigen Methode zuweist. Testfälle: - user1 ruft createdir mit fehlendem Parameter id auf -> Fehler - user1 ruft unbekannten Befehl auf -> Fehler - user1 ruft createdir mit eine String als id auf -> Fehler - user1 ruft updatefile auf ohne den content mitzusenden -> Fehler :return: None """ missingpara_id = {'name': 'id', 'type': int} missingpara_content = {'name': 'content', 'type': str} missingpara_name = {'name': 'name', 'type': str} # Teste Aufruf mit fehlendem Parameter # createdir command benötigt Parameter 'id':parentdirid und 'name': directoryname response = util.documentPoster(self, command='createdir', idpara=None, name='newfolder') # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_id # ü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 unbekannten Befehl ('command') response = util.documentPoster(self, command='DOESNOTEXIST') # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['COMMANDNOTFOUND'] # ü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 Ordners mit einem String als ID response = util.documentPoster(self, command='createdir', idpara='noIntID', name='newfolder') # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_id # ü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 ändern des Inhalt einer .tex Datei ohne den Inhalt mitzusenden response = util.documentPoster(self, command='updatefile', idpara=1) # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_content # ü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 Datei ohne den neuen Namen mitzusenden response = util.documentPoster(self, command='renamefile', idpara=1) # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_name # ü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)
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_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_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_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_Execute(self): """Test der execute() Methode des document view Teste die Verteilfunktion, die die verschiedenen Document-commands den richtigen Methode zuweist. Testfälle: - user1 ruft createdir mit fehlendem Parameter id auf -> Fehler - user1 ruft unbekannten Befehl auf -> Fehler - user1 ruft createdir mit eine String als id auf -> Fehler - user1 ruft updatefile auf ohne den content mitzusenden -> Fehler :return: None """ missingpara_id = {'name': 'id', 'type': int} missingpara_content = {'name': 'content', 'type': str} missingpara_name = {'name': 'name', 'type': str} # Teste Aufruf mit fehlendem Parameter # createdir command benötigt Parameter 'id':parentdirid und 'name': directoryname response = util.documentPoster(self, command='createdir', idpara=None, name='newfolder') # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_id # ü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 unbekannten Befehl ('command') response = util.documentPoster(self, command='DOESNOTEXIST') # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['COMMANDNOTFOUND'] # ü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 Ordners mit einem String als ID response = util.documentPoster(self, command='createdir', idpara='noIntID', name='newfolder') # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_id # ü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 ändern des Inhalt einer .tex Datei ohne den Inhalt mitzusenden response = util.documentPoster(self, command='updatefile', idpara=1) # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_content # ü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 Datei ohne den neuen Namen mitzusenden response = util.documentPoster(self, command='renamefile', idpara=1) # erwartete Antwort des Servers serveranswer = ERROR_MESSAGES['MISSINGPARAMETER'] % missingpara_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)