示例#1
0
    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)
示例#2
0
    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)
示例#3
0
    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)
示例#4
0
    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)
示例#5
0
    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)
示例#6
0
    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())
示例#7
0
    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})
示例#8
0
    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)
示例#9
0
    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)
示例#10
0
    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
        })
示例#12
0
    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
        })
示例#13
0
    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)
示例#14
0
    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)
示例#15
0
    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)
示例#16
0
    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
示例#17
0
    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)