diff --git a/.gitignore b/.gitignore index 406784b..f19cdcf 100644 --- a/.gitignore +++ b/.gitignore @@ -8,8 +8,11 @@ include/ keys/ .venv/ .idea/ - *.kate-swp - +node_modules/ +package-lock.json +package.json # Diagram cache directory media/diagram_cache/ +.env +data/db.sqlite3 diff --git a/Dockerfile b/Dockerfile index 318de06..30105e7 100644 --- a/Dockerfile +++ b/Dockerfile @@ -28,7 +28,10 @@ RUN rm -rf /app/Dockerfile* \ /app/k8s \ /app/data-loader \ /app/keys \ - /app/requirements.txt + /app/requirements.txt \ + /app/node_modules \ + /app/*.json \ + /app/test_*.py RUN python3 manage.py collectstatic CMD ["gunicorn","--bind","0.0.0.0:8000","--workers","3","VorgabenUI.wsgi:application"] diff --git a/R0066.json b/R0066.json new file mode 100644 index 0000000..5ceea92 --- /dev/null +++ b/R0066.json @@ -0,0 +1,1599 @@ +{ + "Vorgabendokument": { + "Typ": "Standard IT-Sicherheit", + "Nummer": "R0066", + "Name": "Logging", + "Autoren": [ + "Adrian A. Baumann", + "Emily Hentgen", + "Arnold Grossmann" + ], + "Pruefende": [ + "Fritz Weyermann" + ], + "Geltungsbereich": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Der vorliegende Standard IT-Sicherheit beinhaltet Definitionen und Anforderungen, die für das Logging im BIT benötigt werden. Das Dokument beschreibt das Thema Logging aus Sicherheitssicht." + }, + { + "typ": "text", + "inhalt": "Es werden keine konkreten Umsetzungen vorgegeben, sondern lediglich die Anforderungen aufgezeigt. Alle Betreiber von Infrastrukturen beim BIT müssen das Vorgehen für die bei Ihnen anfallenden Log-Daten selbst konkretisieren und umsetzen. Das gewählte Vorgehen muss dokumentiert und begründet werden." + }, + { + "typ": "text", + "inhalt": "Nicht Bestandteil des vorliegenden Standards sind die Sammlung und Auswertung von Log-Daten zum Zweck der Überwachung von Services und Systemen um Betriebsaufgaben wahrzunehmen. Bei der Umsetzung macht es jedoch Sinn, die betrieblichen Aspekte mit-einzubeziehen und zu spezifizieren; viele der Log-Daten sind sowohl für die Sicherheit wie auch für den Betrieb von Interesse." + }, + { + "typ": "text", + "inhalt": "Betriebswirtschaftliche Aspekte werden ebenfalls nicht berücksichtigt. Diese müssen in der Umsetzungsplanung berücksichtigt werden. Auch hier können Log-Daten potentiell z.B. für Key Performance Indicators (KPI) verwendet werden." + } + ] + }, + "Ziel": "", + "Grundlagen": "", + "Changelog": [], + "Anhänge": [], + "Verantwortlich": "Information Security Management BIT", + "Klassifizierung": null, + "Glossar": { + "ASCII": "American Standard Code for Information Interchange", + "CSV": "Comma-Separated Values", + "IP": "Internet Protocol", + "NTP": "Network Time Protocol", + "OSSEC": "Open Source HIDS SECurity", + "PIN": "Personal Identification Number", + "SCP": "Secure Copy", + "SLA": "Service Level Agreement", + "TCP": "Transmission Control Protocol", + "TLS": "Transport Layer Security" + }, + "Vorgaben": [ + { + "Nummer": "1", + "Titel": "Inventarisierung der Log-Daten Quellen", + "Thema": "Organisation", + "Kurztext": "TODO", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Übersicht über die Log-Daten-Quellen muss gewährleistet sein. Dafür müssen Log-Daten-Quellen eindeutig identifiziert und systematisch inventarisiert werden. Der Verantwortliche der Log-Datensammlung muss sicherstellen, dass die Dokumentation gepflegt wird und aktuell ist." + }, + { + "typ": "text", + "inhalt": "Folgende Informationen müssen für jede Log-Daten Quelle schriftlich dokumentiert werden:" + }, + { + "typ": "liste", + "inhalt": [ + "Welche Logs aktiviert sind", + "Welche Logs nicht aktiviert sind, inkl. Begründung warum das Logging deaktiviert ist" + ] + } + ] + }, + "Referenz": [ + "IT-Grundschutz, O2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "Die Übersicht über die Logdaten ist gewährleistet", + "Es existiert eine schriftliche Dokumentation für die Logdatenquelle" + ], + "Stichworte": [ + "Logdatenquelle", + "Logdatensammlung", + "Dokumentation" + ] + }, + { + "Nummer": "2", + "Thema": "Organisation", + "Titel": "Dokumentation der Log-Daten Quellen Attribute", + "Kurztext": "Logdaten müssen in einem maschinenlesbaren Format vorliegen.", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Für jede Log-Daten-Quelle soll eine vollständige Dokumentation der Attribute zur Verfügung stehen. Zudem soll schriftlich dokumentiert werden, welche Attribute effektiv geloggt werden. Sollten Attribute nicht geloggt werden, soll dies nachvollziehbar dokumentiert und begründet werden." + } + ] + }, + "Referenz": [ + "IT-Grundschutz, O2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "Es existiert eine Dokumentation der Attribute der Logdatenquelle." + ], + "Stichworte": [ + "Logdatenquelle", + "Dokumentation", + "Attribute" + ] + }, + { + "Nummer": "3", + "Thema": "Organisation", + "Titel": "Dateninhaber", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Für jede Log-Daten Sammlung muss ein Dateninhaber definiert werden." + }, + { + "typ": "text", + "inhalt": "Beim Dateninhaber handelt es sich um eine Person oder ein Bundesorgan, die oder das allein oder zusam-men entscheidet, wer auf die Log-Daten zugreifen darf, wer die Log-Daten bearbeiten darf, und wie die Log-Daten bearbeitet werden dürfen. Der Dateninhaber ist zuständig für die Qualität, Integrität und Sicherheit ihrer Daten." + } + ] + }, + "Referenz": [ + "ISO27001, A8.1.1", + "ISO27001, A8.1.2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "Der Dateninhaber der Logdatensammlung ist definiert." + ], + "Stichworte": [ + "Logdatensammlung", + "Dateninhaber" + ] + }, + { + "Nummer": "4", + "Thema": "Organisation", + "Titel": "Log-Daten Sammlungen mit Personendaten", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Für Log-Daten, die Personendaten beinhalten, oder die die Zusammenstellung von Persönlichkeitsprofilen ermöglichen, gelten die Anforderungen des DSG." + }, + { + "typ": "text", + "inhalt": "Als Personendaten gelten alle Angaben, die sich auf eine bestimmte oder bestimmbare Person beziehen. Als Persönlichkeitsprofil gelten Zusammenstellungen von Daten, die eine Beurteilung wesentlicher Aspekte der Persönlichkeit einer natürlichen Person erlaubt (Art. 3, Bst. a, DSG)." + }, + { + "typ": "text", + "inhalt": "Log-Daten fallen in dieser Kategorie, insofern die geloggten Aktivitäten auf eine bestimmte natürliche Person zurückzuführen sind (z.B. mit einer Benutzer ID). Die Anforderungen zum Auskunftsrecht müssen sichergestellt werden können." + }, + { + "typ": "text", + "inhalt": "Rollen müssen definiert werden, damit die Log-Daten Sammlungen konform und sicher bearbeitet werden." + }, + { + "typ": "text", + "inhalt": "Im Kontext von Log-Daten Sammlungen, die Personendaten beinhalten, werden folgende Rollen definiert:" + }, + { + "typ": "liste", + "inhalt": [ + "*Verantwortlicher*: Beim Verantwortlichen handelt es sich grundsätzlich um den Dateninhaber der Log-Daten Sammlung. Er entscheidet allein oder zusammen mit anderen über den Zweck und die Mittel der Bearbeitung der Log-Daten. Siehe auch: Inhaber der Datensammlung nach DSG", + "*Auftragsbearbeiter*: Beim Auftragsbearbeiter handelt es um eine Person oder ein Bundesorgan, die oder das im Auftrag des Verantwortlichen die Log-Daten bearbeitet. Bemerkung: Der Auftragsbearbeiter ist kein Dritter. Als Dritte gilt einen eigenständigen Verantwortlichen. Er unterscheidet sich vom Auftragsbearbeiter oder von einem gemeinsamen Verantwortlichen im Rahmen der Datenbearbeitung.", + "*Datensubjekt*: Beim Datensubjekt handelt es sich um eine natürliche oder juristische Person, deren persönlichen Daten von einer Organisation gesammelt, gespeichert oder bearbeitet werden." + ] + }, + { + "typ": "text", + "inhalt": "Der Verantwortliche und der Auftragsbearbeiter müssen folgende Informationen schriftlich dokumentieren:" + }, + { + "typ": "tabelle", + "inhalt": "| Was | Verantwortliche | Auftragsbearbeiter |\n|---------------------------------------------------------------------------------------- --------------------------------------|:----------------:|:------------------:|\n| Identität des Verantwortlichen | x | x |\n| Identität des Auftragsbearbeiters | | x |\n| Bearbeitungszweck | x | |\n| Beschreibung der Kategorien betroffener Personen | x | |\n| Beschreibung der Kategorien bearbeiteter Personendaten | x | |\n| Kategorie der Empfängerinnen und Empfänger (Personen, denen Daten bekanntgegeben werden) | x | |\n| Kategorien von Bearbeitungen, die im Auftrag des Verantwortlichen durchgeführt werden | | x |\n| Aufbewahrungsdauer der Log-Daten | x | |\n| Beschreibung der Massnahmen zur Gewährleistung der Datensicherheit | x | x |\n| Falls die Daten ins Ausland bekanntgegeben werden, die Angabe des Staats sowie die Garantien eines geeigneten Datenschutzes | x | x |" + }, + { + "typ": "text", + "inhalt": "Mit dem Begriff \"Bearbeitung\" wird jeder Umgang mit Daten, unabhängig von den angewandten Mitteln und Verfahren, insbesondere das Beschaffen, Speichern, Aufbewahren, Verwenden, Verändern, Bekanntgeben, Archivieren, Löschen oder Vernichten von Daten verstanden (Art. 3 Abs. e, DSG). Unter der Bearbeitung von Log-Daten wird somit verstanden, dass die Log-Daten gelesen (d.h. analysiert), verschoben (rotiert, gelöscht) und die Logging-Mechanismen verändert (Konfiguration des Logging-Dienstes, Ein- resp. Ausschalten des Loggings, etc.) werden können." + } + ] + }, + "Referenz": [ + "IT-Grundschutz O1", + "DSG" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "Die relevanten Rollen zur Logdatensammlung sind definiert", + "Es existiert eine schriftliche Dokumentation der Verantwortlichen und Auftraggeber" + ], + "Stichworte": [ + "Verantwortung", + "Dokumentation", + "Datensammlung" + ] + }, + { + "Nummer": "5", + "Thema": "Organisation", + "Titel": "Dokumentation der Log-Daten Sammlungen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Dokumentation zu den jeweiligen Log-Daten Sammlungen muss gepflegt und aktuell sein." + }, + { + "typ": "text", + "inhalt": "Folgende Informationen müssen für jede Log-Daten Sammlung schriftlich dokumentiert werden:" + }, + { + "typ": "liste", + "inhalt": [ + "Auf welchen Systemen die Logs gesammelt werden", + "Wie lange die Logs pro System aufbewahrt werden", + "Wer Zugriff pro System auf die Logs hat, inkl. mit welchen Privilegien", + "Wer Zugriff auf den Logging-Mechanismus hat, inkl. mit welchen Privilegien" + ] + } + ] + }, + "Referenz": [ + "IT-Grundschutz, O2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "Es existiert eine Liste der relevanten Log-Daten-Sammlungen", + "Die Dokumentation der Log-Daten-Sammlungen ist aktuell" + ], + "Stichworte": [] + }, + { + "Nummer": "6", + "Thema": "Organisation", + "Titel": "Dokumentation der Log-Management Prozesse", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Management Prozesse müssen definiert und schriftlich dokumentiert werden. Es muss ein gemeinsames Verständnis des Lebenszyklus der Log-Daten bestehen, von ihrer Erzeugung bis zu ihrer Vernichtung." + }, + { + "typ": "text", + "inhalt": "Folgende Phasen des Log-Management Prozesses müssen beschrieben werden:" + }, + { + "typ": "liste", + "inhalt": [ + "Policy Definition", + "Konfiguration", + "Sammlung", + "Normalisierung", + "Indexierung", + "Auswertung", + "Korrelierung", + "Baselining", + "Alerting", + "Reporting", + "Aufbewahrung", + "Vernichtung" + ] + }, + { + "typ": "text", + "inhalt": "Alle Phasen sind mit entsprechenden Sicherheitsmechanismen zu unterstützen. Es müssen Kontrollen implementiert werden, die während jeder Phase und bei jedem Übergang zur nächsten Phase sicherstellen, dass die Bearbeitung der Log-Daten sicher und konform ist." + } + ] + }, + "Referenz": [ + "IT-Grundschutz, O2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": 7, + "Thema": "Technik", + "Titel": "Vollständigkeit der Log-Daten Sammlungen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Daten-Sammlungen müssen vollständig sein. Dadurch sollen sich unberechtigte Aktivitäten erkennen lassen, Ereignisse rekonstruiert werden können und Personen rechenschaftspflichtig gemacht werden können.  Zur Sicherstellung der IT-Sicherheit braucht es eine Nachvollziehbarkeit von Handlungen, welche zur Sammlung relativ vieler Daten führen kann. Dazu soll das periodische Abholen oder Abliefern der gesammelten Logs von den Logsammel-Geräten sichergestellt werden. Die Infrastruktur muss zudem fähig sein, Log-Daten bei Wartungsarbeiten oder Ausfällen (bspw. einer Netzwerkkomponente) ohne Datenverluste weiter zu sammeln. Eine Log-Daten-Quelle darf nicht ausfallen, ohne dass dies sofort auffällt. " + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "RVOG Art. 57l" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": 8, + "Thema": "Technik", + "Titel": "Datensparsamkeit", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Bei der Protokollierung dürfen nur so viele Daten bearbeitet werden, wie zur Erfüllung des Zwecks oder des Auftrags notwendig sind. Dabei müssen die jeweils geltenden gesetzlichen und betrieblichen Bestimmungen beachtet werden. Diese besagen unter anderem, dass die Protokollierung von Ereignissen nur zweckgebunden erfolgen darf. Die Protokollierung von Ereignissen zum Zweck der Arbeitskontrolle/Überwachung von Mitarbeitern ist nicht zulässig. Es dürfen nur dort Log-Daten gesammelt und ausgewertet, wo ein Zweck belegbar ist und eine gesetzliche Grundlage vorliegt." + } + ] + }, + "Referenz": [ + "IT-Grundschutz\nT2.1", + "RVOG Art. 57l" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": 9, + "Thema": "Technik", + "Titel": "Relevante Informationen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die protokollierten Informationen müssen die Sicherstellung der IT-Sicherheit ermöglichen. Log-Daten müssen aussagekräftige und zuverlässige Informationen enthalten. Der Grad und der Umfang der geloggten Informationen soll sich an dem Schutzbedarf des Schutzobjekts und der Anforderung an die Nachvollziehbarkeit orientieren. Insbesondere bei Systemen und Schutzobjekten mit erhöhtem Schutzbedarf ist sicherzustellen, dass genügend Informationen geloggt werden, um die IT-Sicherheit aufrechtzuerhalten." + } + ] + }, + "Referenz": [ + "IT-Grundschutz\nT2.1 ", + "RVOG Art. 57l" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": 10, + "Thema": "Technik", + "Titel": "Sicherheitsrelevante Ereignisse und Aktivitäten", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Sicherheitsrelevante Aktivitäten und Ereignisse müssen protokoliert werden, laufend überwacht werden und nachvollziehbar sein." + }, + { + "typ": "text", + "inhalt": "Der Begriff «sicherheitsrelevant» wird verwendet, um die Funktionen oder Mechanismen zu beschreiben, auf die man sich stützt, um die Schutzziele Vertraulichkeit, Integrität, Verfügbarkeit und Nachvollziehbarkeit zu erreichen. Als «sicherheitsrelevant» gelten somit alle Aktivitäten und Ereignisse, die den Betrieb von Sicherheitsfunktionen oder die Bereitstellung von Sicherheitsmechanismen in einer Weise beeinträchtigen können, oder dazu führen könnten, dass Sicherheitsrichtlinien nicht durchgesetzt oder aufrechterhalten werden können." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "11", + "Thema": "Technik", + "Titel": "Aktivitäten, die mit erhöhten Privilegien durchgeführt werden", + "Kurztext": "Alle Aktivitäten, die mit erhöhten Privilegien durchgeführt werden, müssen protokolliert werden, laufend über-wacht werden, und nachvollziehbar sein.", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Als «erhöhte Privilegien» gelten alle Rechte zur Durchführung von Tätigkeiten, welche ein „normaler“ Benutzer nicht durchführen darf. Auf einem Server kann dies Aktionen umfassen, welche Administratoren-Privilegien oder Root-Rechte benötigen. Darunter fallen auch Aktivitäten mithilfe von Administrations-Tools. In Applikatio-nen sind dies typischerweise Privilegien, welche die Administration der Applikation selbst ermöglichen. Der Begriff ist auch für technische Benutzer zutreffend." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "12", + "Thema": "Technik", + "Titel": "Log-Daten-Format", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Daten müssen in einem geeigneten und konsistenten Format für die Bearbeitung bereitgestellt werden. So-weit möglich muss sichergestellt werden, dass Log-Daten in den bestehenden Lösungen zur Sicherstellung der IT-Sicherheit integriert werden können." + }, + { + "typ": "text", + "inhalt": "Log-Daten aus heterogenen Quellen sollen, wo technisch möglich und sinnvoll, vereinheitlicht werden, um die Komplexität der Log-Infrastruktur in Grenze zu halten. Dabei soll sichergestellt werden, dass die Log-Daten por-tierbar bleiben." + }, + { + "typ": "text", + "inhalt": "Soweit möglich sollen proprietäre Formate vermieden werden. Log-Daten in einem proprietären Format müssen zumindest lokal auf den Systemen gespeichert werden." + }, + { + "typ": "text", + "inhalt": "Wenn als Logformat ein freies ASCII-Textformat (z.B. CSV-Format) mit vordefiniertem Header verlangt ist, muss: " + }, + { + "typ": "liste", + "inhalt": [ + "Das Headerfile dokumentiert und dem Logauswerter bekannt gegeben werden.", + "Die vordefinierten Header dürfen nur in Absprache mit dem Logempfänger abgeändert werden." + ] + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "12", + "Thema": "Technik", + "Titel": "Zeitliche Identifikation", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Bei der Protokollierung muss immer eine eindeutige zeitliche Identifikation geloggt werden, um die Rekonstruktion von Sicherheitsvorfällen zu ermöglichen. Als Identifikation müssen Datum und Zeit gewählt werden, sodass eine eindeutige zeitliche Korrelation der Log-Daten möglich wird. Da das Format HH:MM:SS für die notwendige Eindeutigkeit nicht ausreicht, muss zusätzlich die Millisekunde geloggt werden. In diesem Sinne muss auch sichergestellt werden, dass das Datums- und Zeitformat der verschiedenen Log-Daten einheitlich ist." + }, + { + "typ": "text", + "inhalt": "Sollten Zeit-Synchronisationsprobleme zwischen Diensten auftauchen, erschwert dies die zeitliche Rekonstruktion von Sicherheitsvorfällen. Hierzu muss die korrekte Synchronisation der Systemzeit mit der NTP-Infrastruktur des Bundes oder einem AD-Service sichergestellt werden." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "13", + "Thema": "Technik", + "Titel": "Benutzer-Identifikation", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Bei der Protokollierung muss eine eindeutige Benutzer-Identifikation geloggt werden, die auf eine natürliche Person zurückführt, damit Aktivitäten einem eindeutigen Benutzer zugeordnet werden können. Der Benutzer, dessen Aktivitäten die Erzeugung der Log-Daten ausgelöst hat, muss eindeutig identifiziert werden können. Rollenwechsel zwischen Accounts, welche natürlichen Personen zugeordnet sind, und generischen Accounts, müssen so geloggt werden, dass eine weitere Zuordnung zum Ursprungs-Account (der Person) bestehen bleibt." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "14", + "Thema": "Technik", + "Titel": "System-Identifikation", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Bei der Protokollierung muss eine eindeutige System-Identifikation geloggt werden, die auf ein eindeutiges System zurückführt, wovon die Aktivitäten durchgeführt wurden (Hostname, IP-Adresse, etc.), damit Aktivitäten einem eindeutigen System zugeordnet werden können." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "15", + "Thema": "Technik", + "Titel": "Realtime-Analyse", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Eine Realtime-Analyse muss für Log-Daten möglich sein, welche eine direkte Sicherheitsrelevanz haben, d.h. Komponenten, welche aus Sicherheitsgründen etabliert worden sind (Firewall, Gateway, Virenscanner, etc.). Sicherheitsrelevante Log-Daten sind laufend auszuwerten. Bei vermuteten oder bestätigten Sicherheitsvorfällen sind angemessenen Prozesse zeitnah auszulösen. Durch die laufende Auswertung von Log-Daten (Real-time-Analyse) sollen somit Sicherheitsvorfälle schnellstmöglich erkannt werden." + }, + { + "typ": "text", + "inhalt": "Beim Bezug von internen oder externen Dienstleistungen ist sicherzustellen, dass die Auswertung der Log-Daten in die ordentlichen Betriebsprozesse integriert wird" + }, + { + "typ": "text", + "inhalt": "Die Möglichkeit einer Offline-Analyse der Daten muss auch dort vorgesehen werden, wo eine erhöhte Nachvollziehbarkeit gefordert ist (z.B. um ein bestimmtes Ereignis im Nachhinein genauer oder überhaupt nachvollziehen zu können). Grundsätzlich werden die Daten nicht in Realtime übertragen, d.h. die Daten werden lokal gesammelt und zu einem bestimmten Zeitpunkt übertragen und für die Offline-Analyse bereitgestellt. Offline bedeutet in diesem Zusammenhang, dass ein begrenztes und abgeschlossenes Paket mit Log-Daten auf einem zweiten System analysiert wird, z.B. nach einem Logrotate. Die Offline-Analyse kann auch Daten umfassen, welche zuvor bereits der Realtime-Analyse dienten. Offline-Analysen sollten jedoch nur im Ausnahmefall erfolgen. In der Regel ist eine Realtime-Analyse der Log-Daten zu bevorzugen." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "16", + "Thema": "Technik", + "Titel": "Priorisierung der Auswertungen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Auswertung der Log-Daten muss bezüglich der IT-Sicherheit priorisiert werden und systematisch erfolgen, um eine möglichst zeitnahe Reaktion auf Sicherheitsvorfälle sicherzustellen. Es müssen zuerst diejenigen Log-Daten von Systemen analysiert werden, welche entweder an einer neuralgischen Stelle (z.B. Netzwerkübergang) stehen oder welche Daten mit hohen Sicherheitsanforderungen enthalten." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "17", + "Thema": "Technik", + "Titel": "Auswertung von korrelierten Log-Daten", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Korrelierte Log-Daten müssen sicher und konform bearbeitet werden. Es wird zwischen normalen und korrelierten Log-Daten unterschieden. Die normalen Log-Daten sind Daten, welche im Betrieb anfallen. Korrelierte Log-Daten sind Daten, welche zur Analyse mit weiteren Datensätzen aufbereitet wurden und es unter Umständen ermöglichen, ein Profil (z.B. eines Benutzers) zu erstellen. Der Zugriff auf korrelierten Log-Daten muss beschränkt werden, da die Auswertung von korrelierten Log-Daten heikel werden kann. Persönlichkeitsprofile nach DSG sind besonders schützenswerten Personendaten gleichgestellt." + }, + { + "typ": "text", + "inhalt": "Die Auswertung und Korrelation der Daten dürfen nur unter Berücksichtigung des Datenschutzes und der gesetzlichen Grundlagen erfolgen. Durch die Korrelation können unter Umständen von der Schutzwürdigkeit her unbedenkliche Daten zu besonders schützenswerten Daten oder Persönlichkeitsprofilen gewandelt werden. Dieser Eventualität muss bereits bei der Planung der Auswertung von Log-Daten Rechnung getragen werden. Im Zweifelsfall muss der Rechtsdienst des BIT kontaktiert werden." + }, + { + "typ": "text", + "inhalt": "Falls die korrelierten Daten besonders schützenswerte Personendaten beinhalten oder die Zusammenstellung von besonders schützenswerte Persönlichkeitsprofilen ermöglichen, muss für die Auswertung der korrelierten Daten ein bewilligtes Datenschutzbearbeitungsreglement vorliegen." + }, + { + "typ": "text", + "inhalt": "Für die Vergabe der entsprechenden Rechte bei besonders schützenswerten Personendaten oder Persönlichkeitsprofilen ist der Rechtsdienst BIT zuständig. Für die in einem entsprechenden Datenbearbeitungsreglement vorgesehenen Rollen wird die Zustimmung implizit angenommen." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "Least-Privilege-Prinzip", + "Need-to-Know Prinzip" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "18", + "Thema": "Technik", + "Titel": "Zugriffsberechtigungen auf Log-Daten", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Zugriffsberechtigungen auf Log-Daten müssen nach dem Least-Privilege-Prinzip und dem Need-to-Know-Prinzip vergeben werden." + }, + { + "typ": "text", + "inhalt": "Zum Schutz der Log-Daten muss jeder Zugriff auf den Log-Daten und jede Auswertung dieser mit persönlichen Accounts erfolgen und nachvollziehbar sein. Der Zugriff auf Log-Daten ist einer eindeutigen natürlichen Person zurückzuführen. Ausnahmen dazu sind rein maschinelle Auswertungen, die keine natürliche Person zugeordnet werden können." + }, + { + "typ": "text", + "inhalt": "Der Zugriff auf Log- und korrelierten Betriebsdaten ist auf die folgenden Rollen beschränkt:" + }, + { + "typ": "liste", + "inhalt": [ + "CSIRT Mitarbeitende", + "Betreiber", + "Dateninhaber", + "Datenschutzverantwortlicher (nach DSG), nach Prüfung durch den Rechtsdienst des Dateninhabers", + "Supportfunktionen, nach Prüfung durch den Rechtsdienst des Dateninhabers", + "Alle vom Dateninhaber sonstigen berechtigten Rollen (z.B. Entwickler, Anwendungsbetreuer, Auditor, etc.)" + ] + }, + { + "typ": "text", + "inhalt": "Für die Vergabe der entsprechenden Rechte ist immer der Dateninhaber zuständig. Bei den Betreibern wird die Zustimmung implizit angenommen. Betreiber von Systemen dürfen nur die Log-Daten von den Systemen sehen, korrelieren, oder auswerten, die sie auch betreiben." + }, + { + "typ": "text", + "inhalt": "Folgende Rollen dürfen Leserecht auf ihren Log-Daten und den zugehörigen Logging-Mechanismen haben. Dabei beinhaltet das Leserecht kein Recht zum vollständigen Kopieren der Log-Daten. Die Log-Daten dürfen die Plattform nur auszugsweise verlassen:" + }, + { + "typ": "tabelle", + "inhalt": "| Rolle | Gründe | Art der Daten |\n|--------------------------------------------|-------------------|---------------------------------------------|\n|Betreiber des Services (z.B. DB-Admin) |Serviceerbringung |Log-Daten (auch korreliert) des Service |\n|Betreiber der Anwendung |Serviceerbringung |Log-Daten (auch korreliert) der Anwendung |\n|Betreiber des Systems (z.B. System-Admin) |Serviceerbringung |Log-Daten (auch korreliert) der Systeme |\n|Betreiber der Plattform |Serviceerbringung |Log-Daten (auch korreliert) der Plattform |" + }, + { + "typ": "text", + "inhalt": "Folgende Rollen dürfen Leserecht auf die Log-Daten haben:" + }, + { + "typ": "tabelle", + "inhalt": "|Rolle | Gründe | Art der Daten |\n|-------------------------------------------------------------------------------------------|---------------------------------------------------|---------------------------------------------------------------------------------|\n|CSIRT-Mitarbeitende | Security-Incidentmanagement | Alle Log-Daten inkl. korrelierter Daten |\n|SI-SUR Mitarbeitende | Security-Incidentmanagement, Kontrolle, Prüfungen | Alle Log-Daten inkl. korrelierter Daten |\n|Externer (nicht-BIT) Leistungserbringer (z.B. externer Entwickler, externer Support, etc.) | Serviceerbringung | Log-Daten nach Absprache mit dem ISBO des für die Daten verantwortlichen Amtes |\n|Interner (BIT) Leistungserbringer (z.B. Entwickler, Support, etc.) | Serviceerbringung | Log-Daten welche für die Leistungserbringung notwendig sind |\n|Leistungsbezüger | Kontrolle | Log-Daten wie nach SLA vereinbart |\n|Informationsschutzverantwortlicher | Kontrolle | Alle Log-Daten inkl. korrelierter Daten |\n|Datenschutzverantwortlicher | Kontrolle | Alle Log-Daten inkl. korrelierter Daten |" + }, + { + "typ": "text", + "inhalt": "Rollen, die in keine der oben aufgeführten Kategorien gehören, dürfen ohne Einwilligung des Dateninhabers keinen Zugriff auf die Log-Daten haben." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "Least-Privilege-Prinzip", + "Need-to-Know Prinzip" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "19", + "Thema": "Technik", + "Titel": "Aufbewahrung", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Log-Daten müssen revisionssicher und konform aufbewahrt werden. Die Vertraulichkeit und Integrität der Log-Daten müssen bei deren Aufbewahrung jederzeit gewährleistet werden." + }, + { + "typ": "text", + "inhalt": "Bei der Aufbewahrung der Log-Daten muss sichergestellt werden, dass" + }, + { + "typ": "liste", + "inhalt": [ + "alle benötigten Log-Daten aufbewahrt werden", + "die Log-Daten vor unberechtigter Einsichtnahme geschützt werden", + "die Log-Daten vor unautorisierten Manipulationen geschützt werden", + "die Log-Daten vor Verlust geschützt werden", + "die Log-Daten nicht länger aufbewahrt werden, als deren Bearbeitungszweck es vorsieht", + "archivierte Log-Daten bei Bedarf mit vertretbarem Aufwand abgerufen werden können", + "die Service Level Agreements (SLA) der Kundinnen und Kunden in Hinsicht auf Aufbewahrung eingehalten werden" + ] + }, + { + "typ": "text", + "inhalt": "Dafür müssen Kontrollen implementiert werden, welche die revisionssichere und konforme Aufbewahrung von Log-Daten sicherstellen." + }, + { + "typ": "text", + "inhalt": "Logs sind verschlüsselt zu speichern (Harddisk: verschlüsselte Partition; Backup: verschlüsseltes File)." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "IT-Grundschutz I2", + "IT-Grundschutz I3" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "20", + "Thema": "Technik", + "Titel": "Aufbewahrungsfristen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Aufbewahrungsfristen der Log-Daten müssen die Sicherstellung der IT-Sicherheit ermöglichen und müssen mit den bundesweiten Vorgaben und Gesetzen konform sein." + }, + { + "typ": "text", + "inhalt": "Bei der Aufbewahrung von Log-Daten wird zwischen Schnellzugriffs-Speicher und Langzeitaufbewahrung differenziert. Bei Schnellzugriffs-Speicher können Log-Daten mit geringem Aufwand und innerhalb kurzer Zeit abgerufen werden. Bei der Langzeitaufbewahrung werden die Log-Daten langfristig archiviert. Obwohl archivierte Log-Daten weiterhin verfügbar sind, ist deren Abruf jedoch wesentlich aufwändiger im Vergleich zu einer Aufbewahrung in einem Schnellzugriffs-Speicher." + }, + { + "typ": "text", + "inhalt": "Log-Daten müssen mindestens 3 Monate (90 Tage) im Schnellzugriffs-Speicher aufbewahrt werden und durchsuchbar sein." + }, + { + "typ": "text", + "inhalt": "Log-Daten, die Personendaten enthalten oder aus denen Rückschlüsse auf Personen möglich sind," + }, + { + "typ": "liste", + "inhalt": [ + "müssen mindestens 1 Jahr langfristig getrennt vom System, in welchem die Personendaten bearbeitet werden, aufbewahrt werden (Art. 4, Abs. 5, DSV)", + "dürfen maximal 2 Jahre aufbewahrt werden (Art. 4, VPNIB). Für eine längere Aufbewahrungsfrist ist eine separate rechtliche Grundlage notwendig." + ] + }, + { + "typ": "text", + "inhalt": "Log-Daten, die keine Personendaten enthalten und aus denen keine Rückschlüsse auf Personen möglich sind," + }, + { + "typ": "liste", + "inhalt": [ + "dürfen langfristig aufbewahrt werden, insofern diese archivwürdig sind (Art. 7, BGA)", + "archivwürdig sind Unterlagen, die von juristischer oder administrativer Bedeutung sind oder einen grossen Informationswert haben (Art. 3, Abs. 3, BGA)", + "die Archivwürdigkeit der Log-Daten muss zwischen dem Dateninhaber und dem Schweizerischen Bundesarchiv (BAR) bewertet werden (Art. 7, BGA, Art.6, VBGA)", + "archivwürdige Log-Daten müssen archiviert werden, wenn die Log-Daten nicht mehr häufig oder regelmässig gebraucht werden, jedoch spätestens 5 Jahre nach dem letzten Aktenzuwachs (Art. 4, Abs. 1, VBGA)" + ] + }, + { + "typ": "text", + "inhalt": "Log-Daten von Netzwerkgeräten müssen mindestens 2 Jahre lang aufbewahrt werden (BRB 1c)). Die langfristige Aufbewahrung darf offline erfolgen (Archivierung)." + }, + { + "typ": "text", + "inhalt": "Bei staatsrechnungsrelevanten Applikationen müssen die relevanten Log-Daten mindestens 6 Monate lang in Speichern mit schneller Zugriffsmöglichkeit aufbewahrt werden. Die 6 Monate entsprechen einem halben Prüfungsjahr. Zusätzlich zu den 6 Monaten sollte eine zeitliche Abgrenzungsreserve von 1 Monat vorgesehen werden. Nach Abschluss der Frist müssen die Log-Daten von staatsrechnungsrelevanten Applikationen nachträglich langfristig aufbewahrt werden (Archivierung) und unter Berücksichtigung der VPNIB und DSG Vorschriften. Für kürzere Zeiträume der maximalen Aufbewahrungsdauer im Schnellzugriffs-Speicher ist die Eidgenössische Finanzkontrolle (EFK) beizuziehen." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "IT-Grundschutz I2", + "IT-Grundschutz I3" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "21", + "Thema": "Technik", + "Titel": "Löschung und Vernichtung", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Daten müssen revisionssicher und konform gelöscht und vernichtet werden." + }, + { + "typ": "text", + "inhalt": "Die Löschung von Daten bezeichnet generell die Unkenntlichmachung von Daten. Die Vernichtung von Daten bezieht sich meist auf die physische Zerstörung des Speichermediums. In beiden Fällen soll die Rekonstruktion der ursprünglichen Daten praktisch undurchführbar sein." + }, + { + "typ": "text", + "inhalt": "Bei der Löschung bzw. Vernichtung von Log-Daten sind folgende Anforderungen zu beachten:" + }, + { + "typ": "liste", + "inhalt": [ + "Log-Daten dürfen nur nach Ablauf ihrer Aufbewahrungsfrist gelöscht oder vernichtet werden.", + "Log-Daten müssen nach Ablauf ihrer Aufbewahrungsfrist, entsprechend den betrieblichen Umständen, möglichst zeitnah gelöscht bzw. vernichtet werden. Spätestens 3 Monate nach Ablauf der Aufbewahrungsfrist sind die Log-Daten zu löschen oder zu vernichten (Art. 4, Abs. 2, VPNIB).", + "Nur die vom Verantwortlichen bestimmten Personen dürfen, in ihrer Rolle als Auftragsbearbeiter, Log-Daten löschen oder vernichten, bzw. die entsprechenden Prozesse zum Löschen oder Vernichten der Log-Daten einleiten.", + "Zu Verifizierungszwecken ist die Löschung und Vernichtung von Log-Daten zu protokollieren.", + "Die Log-Daten sind nach einem festgelegten Verfahren und auf konsistente Weise zu löschen bzw. zu vernichten." + ] + }, + { + "typ": "text", + "inhalt": "Datenträger, auf welchen die Log-Daten gespeichert sind, sind durch das Bundesamt für Bauten und Logistik (BBL) zu entsorgen. Für die Entsorgung sind die Vorgaben zur Entsorgung elektronischer Datenträger zu beachten. Je nach Schutzobjekt sind auch die Anforderungen des entsprechenden ISDS-Konzeptes zu beachten." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "IT-Grundschutz I2", + "IT-Grundschutz I3", + "VPNIB" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "22", + "Thema": "Technik", + "Titel": "Änderungen an Logging-Mechanismen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Änderungen an Logging-Mechanismen und Protokollierungseinstellungen sind kontinuierlich zu überwachen. Das Starten, Stoppen und Pausieren der Protokollierung müssen überwacht werden. Die Protokollierung darf nicht pausiert oder gestoppt werden, ohne dass dies sofort auffällt. Sämtliche Zugriffe auf Protokollierungseinstellungen müssen überwacht werden. Zugriffe auf Protokollierungseinstellungen müssen mit persönlichen Accounts erfolgen, schriftlich begründet sein und nachvollziehbar sein." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "23", + "Thema": "Technik", + "Titel": "Überwachung des Logging-Prozesses", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Fehlkonfigurationen und Fehlverhalten im Logging-Prozess sind rechtzeitig zu erkennen. Alerts müssen eingerichtet werden, um Fehlkonfigurationen und Fehlverhalten im Logging-Prozess schnellstmöglich zu erkennen und zu beheben." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "24", + "Thema": "Technik", + "Titel": "Testen der Logging-Mechanismen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Logging-Mechanismen müssen ordnungsgemäss getestet werden, bevor sie produktiv eingerichtet und verwendet werden. Somit soll sichergestellt werden, dass Log-Daten korrekt bearbeitet werden. Gleichzeitig soll vermieden werden, dass Log-Daten aufgrund fehlerhaft eingerichteter Logging-Mechanismen verloren gehen." + }, + { + "typ": "text", + "inhalt": "Bei der Einrichtung der Logging-Mechanismen muss auch sichergestellt werden, dass keine sensiblen Daten geloggt werden. Werden sensible Daten geloggt, müssen sie vorab angemessen obfuskiert werden, z.B. durch Hashing. Zudem muss sichergestellt werden, dass die Protokollierung von personenbezogenen Daten innerhalb des rechtlichen Rahmens bleibt. Die Logging-Mechanismen müssen zusammen mit dem Gesamtsystem vor ihrem produktiven Einsatz formell abgenommen werden." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "25", + "Thema": "Technik", + "Titel": "Trennung der logdatensammelnden und der logdatenproduzierenden Systeme", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Daten müssen vor einer gewollten (z.B. durch einen Angreifenden) oder versehentlichen Manipulation (z.B. durch einen Benutzenden oder eine Applikation) von Nicht-Administratoren geschützt werden. Dies soll durch die Trennung der logdatenproduzierenden und der logdatensammelnden Systeme erreicht werden." + }, + { + "typ": "text", + "inhalt": "Log-Daten müssen mittels geeigneter Technologie an einen Speicherort verschoben werden, welcher physisch vom logdatenproduzierenden System getrennt ist. Die Weiterleitung muss ohne Verzögerung erfolgen." + }, + { + "typ": "text", + "inhalt": "Der Zugriff auf das logdatensammelnde System und insbesondere auf die Log-Daten selbst muss stark eingeschränkt und lediglich einem kleinen und wohldefinierten Personenkreis vorbehalten werden (Need-to-Know Prinzip). Die Liste der erlaubten Personen muss schriftlich dokumentiert werden und jederzeit aktuell gehalten werden." + }, + { + "typ": "text", + "inhalt": "Die Trennung zwischen dem logdatensammelnden System und dem logdatenproduzierenden System folgt dem Sicherheitsprinzip gemäss Funktionstrennung (Separation-of-Duty)." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "IT-Grundschutz I2.2", + "Need-to-Know Prinzip" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "26", + "Thema": "Technik", + "Titel": "Logdatensammler-Infrastruktur", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Daten müssen an einer dedizierten zentralen Logdatensammelstelle gesammelt werden. Werden Log-Daten nicht systematisch an einer dedizierten zentralen Logdatensammelstelle gesammelt und nur lokal gespeichert, besteht das Risiko, dass Log-Daten verloren gehen (z.B bei Wartungsarbeiten oder Ausfällen) oder nicht brauchbar sind." + }, + { + "typ": "text", + "inhalt": "Die Logdatensammler-Infrastruktur muss dazu fähig sein, die erzeugte Menge an Log-Daten zu verarbeiten und somit entsprechend skalierbar sein. Gegebenenfalls sollte die Logdatensammler-Infrastruktur hochverfügbar sein." + }, + { + "typ": "text", + "inhalt": "Die Infrastruktur zum zentralen Sammeln der Log-Daten muss zudem folgende Bedingungen erfüllen:" + }, + { + "typ": "liste", + "inhalt": [ + "Die Anforderungen aus der Sicherheit an die Logdatensammler-Infrastruktur ergeben sich aus dem höchsten geforderten Schutzziel aller auf der Infrastruktur bearbeiteten Daten (Maximumprinzip).", + "Für die jeweiligen Infrastrukturen müssen ISDS-Konzepte erstellt werden.", + "Um die Netzwerkverkehr zu minimieren, sollen die Logsammel-Geräte möglichst nahe (Netzwerktechnisch) an den logproduzierenden Geräten stehen." + ] + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "IT-Grundschutz I2.2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "27", + "Thema": "Technik", + "Titel": "Gemanagte Konfiguration der Protokollierung", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Konfiguration der Protokollierung soll systemübergreifend konsistent sein. Dabei soll die Konfiguration der Protokollierung pro Teilgebiet (Netzwerk, Datenbanken, Applikationen, etc.) an einer zentralen Stelle hinterlegt und verwaltet werden. Dadurch werden inkonsistente lokale Konfigurationen vermieden. Zudem reduzieren sich Arbeitsaufwände, wenn Konfigurationen weitmöglichst zentral verwaltet werden, anstatt lokal auf jedem einzelnen System." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "28", + "Thema": "Technik", + "Titel": "Härtung der Logsammler-Geräte", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Geräte zum Sammeln der Log-Daten müssen gehärtet sein." + }, + { + "typ": "text", + "inhalt": "Folgende Bedingungen müssen erfüllt werden:" + }, + { + "typ": "liste", + "inhalt": [ + "Die Geräte müssen nach den Vorgaben der IT-Sicherheit konfiguriert sein (Einhaltung der Standards und Richtlinien).", + "Die Geräte müssen zusätzlich gehärtet werden (z.B. mit lokal installierter Firewall). Sind spezifische Vorgaben zur Härtung vorhanden, müssen diese eingehalten werden.", + "Die Geräte müssen über einen Integritätscheck verfügen (z.B. OSSEC).", + "Die Geräte müssen das Abholen der offline Log-Daten mittels SCP ermöglichen.", + "Die Geräte müssen das Abholen der online Log-Daten mittels TLS over TCP ermöglichen.", + "Die Geräte müssen so konfiguriert werden, dass die Speicher für die Log-Daten ausreichend gross bemessen sind. D.h. der Speicher darf zwischen zwei Backup-Zyklen weder überlaufen, noch soll ein Überschreiben der Log-Daten notwendig werden.", + "Die Geräte sollen über Mandantenfähigkeit verfügen.", + "Die Geräte stehen in einem Administrations-Netzwerk oder in einer dedizierten Logging-Zone.", + "Die Geräte sollen hierarchisch gegliedert werden." + ] + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1", + "IT-Grundschutz I1", + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "29", + "Thema": "Technik", + "Titel": "Log-Daten-Beatbeitung in einer Cloud-Lösung", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Bearbeitung von Log-Daten in einer Cloud-Lösung muss konform mit den IT-Sicherheitsvorgaben des BIT und den bundesweiten Vorgaben und Gesetze sein." + }, + { + "typ": "text", + "inhalt": "Die Bearbeitung der Log-Daten in einer Cloud-Lösung durch den Auftragsbearbeiter ist zwischen dem Verantwortlichen und dem Auftragsbearbeiter vertraglich zu regeln. Der Verantwortliche muss sich vor dem Vertragsabschluss vergewissern, dass der Auftragsbearbeiter in der Lage ist, die Sicherheit der Log-Daten zu gewährleisten. Der Schutz der Log-Daten muss nachweislich gleich so hoch sein wie bei einer On-Premises Lösung. Bei der Beurteilung der Sicherheit sind die Schutzziele Vertraulichkeit, Integrität, Verfügbarkeit und Nachvollziehbarkeit zu berücksichtigen." + }, + { + "typ": "text", + "inhalt": "Zudem muss nachgewiesen werden, dass allfällige zusätzliche Risiken, die durch eine Bearbeitung der Log-Daten in einer Cloud-Lösung entstehen, tragbar sind. Das Nutzen einer Bearbeitung von Log-Daten in einer Cloud-Lösung sollte die daraus entstehenden Risiken überwiegen. Sollte das nicht möglich sind, sind kompensierende Massnahmen zur Risikominimierung zu definieren und umzusetzen." + }, + { + "typ": "text", + "inhalt": "Der Verantwortliche muss sich auch vergewissern, dass die Log-Daten vom Auftragsbearbeiter gleich bearbeitet werden, wie der Verantwortliche es selbst tun dürfte." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "30", + "Thema": "Technik", + "Titel": "Cloud-Dienste", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Visibilität über sicherheitsrelevante Ereignisse und Aktivitäten betreffend Schutzobjekte, die Cloud-Dienste beziehen, muss gewährleistet werden." + }, + { + "typ": "text", + "inhalt": "Beim Bezug von Cloud-Diensten sind folgende Punkte abzuklären und schriftlich zu dokumentieren:" + }, + { + "typ": "liste", + "inhalt": [ + "Welche Log-Daten werden generiert", + "Wo werden die Log-Daten aufbewahrt", + "Wie werden die Log-Daten gesichert", + "Werden die Log-Daten verschlüsselt und falls ja, wie die Verschlüsselung gehandhabt wird (Verschlüsselungsalgorithmus, Schlüssel-Management, etc.)" + ] + }, + { + "typ": "text", + "inhalt": "Der Serviceverantwortliche oder der Applikationsverantwortliche muss sich vergewissern, dass er genügend Einsicht in die Log-Daten hat, um die IT-Sicherheit zu gewährleisten. In diesem Sinne muss er sich auch vergewissern, dass angemessenen Schnittstellen zur Verfügung stehen, damit Log-Daten abgerufen und ausgewertet werden können." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "31", + "Thema": "Technik", + "Titel": "Integration in bestehende Lösungen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Cloud-Logs müssen in die bestehenden Lösungen zur Log-Daten Bearbeitung integriert werden. Das Prinzip der zentralen Sammlung der Log-Daten darf durch einen Cloud-Service nicht gebrochen werden. Die Cloud-Logs müssen mit den On-Premise Log-Daten korreliert werden können." + }, + { + "typ": "text", + "inhalt": "Cloud-Logs müssen zudem in einem geeigneten und konsistenten Format für die Bearbeitung bereitgestellt werden. In diesem Sinne muss sichergestellt werden, dass Cloud-Logs in den bestehenden Lösungen zur Sicherstellung der IT-Sicherheit integriert werden können und die Auswertung der Cloud-Logs in die ordentlichen Betriebsprozesse integriert wird." + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "32", + "Thema": "Informationen", + "Titel": "Protokollierung von Zugriffen auf sensible Daten", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Zugriffe auf sensible Daten müssen protokolliert werden, laufend überwacht werden und nachvollziehbar sein." + }, + { + "typ": "text", + "inhalt": "Als sensible Daten gelten u.a.:" + }, + { + "typ": "liste", + "inhalt": [ + "Authentifikationsdaten (Passwörter, Schlüssel, Zertifikate, etc.)", + "Konfigurationsdateien", + "Audit-Logs", + "Besonders schützenswerte Personendaten oder Persönlichkeitsprofilen (nach DSG)", + "GEHEIM-klassifizierte Informationen (nach ISchV)", + "Finanziell relevante Daten (Buchhaltungsdaten, Inventardaten, etc.)", + "Geschäftskritische Daten", + "Alle sonstigen Daten, welche in einer Schutzbedarfsanalyse als schützenswert bezüglich der Vertraulichkeit definiert wurden" + ] + } + ] + }, + "Referenz": [ + "IT-Grundschutz T2.1" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "33", + "Thema": "Informationen", + "Titel": "Schutz von Geheimnissen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Geheimnisse sind bei der Bearbeitung von Log-Daten angemessen zu schützen. Es muss sichergestellt werden, dass keine Geheimnisse (z.B. Passwörter, private Schlüssel, PIN Codes, etc.) geloggt werden. Werden Geheimnisse geloggt, müssen sie vorab angemessen obfuskiert oder maskiert werden, z.B. durch Hashing oder *********." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "34", + "Thema": "Informationen", + "Titel": "Bearbeitung von besonders schützenswerten Personendaten", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Bearbeitung von besonders schützenswerten Personendaten muss konform mit den bundesweiten Vorgaben und Gesetze sein. Für jede Log-Datensammlung mit besonders schützenswerten Personendaten muss ein bewilligtes Datenschutzbearbeitungsreglement und ein bewilligtes Berechtigungskonzept existieren." + }, + { + "typ": "text", + "inhalt": "Des Weiteren muss eine Datenschutzvereinbarung zwischen dem Verantwortlichen und dem Auftragsbearbeiter abgeschlossen werden. Die Datenschutzvereinbarung muss folgende Punkte adressieren:" + }, + { + "typ": "liste", + "inhalt": [ + "Zweck der Bearbeitung", + "Priorisierung der Datensicherheit", + "Meldungspflicht bei Feststellungen von allfälligen Gefährdungen der Datensammlung", + "Geheimhaltungsverpflichtung, inkl. nach Beendigung des Auftrags", + "Datenbekanntgabe an Dritte" + ] + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "35", + "Thema": "Informationen", + "Titel": "Schutzbedarf", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Der Schutzbedarf der Log-Daten, muss bekannt sein, damit angemessenen Massnahmen zum Schutz der Log-Daten getroffen werden Der Schutzbedarf der Log-Daten ist vom Dateninhaber zu beurteilen und festzulegen. " + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "36", + "Thema": "Informationen", + "Titel": "Transport", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Der Transport von Log-Daten muss möglichst zeitnah zur Erzeugung der Logs erfolgen, um eine Out-of-Band-Analyse zu ermöglichen. Der Zeitraum richtet sich nach den Sicherheits-Anforderungen und muss jeweils einzeln abgesprochen, bzw. geregelt werden. Log-Daten sind standardmässig in Echtzeit zu übermitteln. Für Transfers von grossen Log-Datenmengen sollen Randstunden gewählt werden. " + }, + { + "typ": "text", + "inhalt": "Für die periodische offline-Datenübertragung kann ein Standard ZIP-File (Bzip, ZIP) verwendet werden." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "37", + "Thema": "Informationen", + "Titel": "Protokolle", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Für die Übertragung der Daten soll das Syslog-Protokoll (RFC5424) eingesetzt werden, welches heute de facto einem Industriestandard entspricht, soweit keine herstellerspezifischen Vorgaben oder Empfehlungen (z.B. Eventforwarding unter Windows) existieren. Beispiel für eine entsprechende Software ist die freie Implementierung Syslog-NG. Für die Übertragung sind auf jeden Fall TCP-Protokolle den UDP-Protokollen vorzuziehen." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "38", + "Thema": "Informationen", + "Titel": "Schutz der Log-Daten während des Transports", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Die Vertraulichkeit und die Integrität der Log-Daten müssen auf dem Transportweg mittels geeigneter Technik jederzeit gewährleistet werden. Die Transportwege müssen sicher sein und mit einem aktuellen TLS Protokoll geschützt werden. Ist dies nicht möglich, müssen die Daten auf andere Art kryptographisch geschützt werden (z.B. mittels verschlüsseltem ZIP-File). Solche Abweichungen müssen schriftlich dokumentiert werden." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "39", + "Thema": "Informationen", + "Titel": "Zonen mit tieferem Sicherheitsniveau", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Daten müssen in einer Zone aufbewahrt werden, deren Schutzniveau der Schutzbedarf der Log-Daten entspricht. Falls Log-Daten von einer Zone mit höherem Sicherheitsniveau nach einer Zone mit tieferem Sicherheitsniveau übermittelt werden müssen, muss sichergestellt werden, dass die Sicherheit der Log-Daten bei der Übertragung und bei der Aufbewahrung nicht wesentlich beeinträchtigt wird." + }, + { + "typ": "text", + "inhalt": "Log-Daten dürfen in einer Zone mit tieferem Sicherheitsniveau übermittelt werden, sofern eine Risikoanalyse gezeigt hat, dass" + }, + { + "typ": "liste", + "inhalt": [ + "der Nutzen die daraus entstehenden Risiken überwiegt", + "die Risiken tragbar sind" + ] + }, + { + "typ": "text", + "inhalt": "Sollte die Risikoanalyse wiederum zeigen, dass die Weiterleitung der Log-Daten nach einer Zone mit tieferem Sicherheitsniveau die Sicherheit der Log-Daten wesentlich beeinträchtigt, dürfen die Log-Daten nicht nach dieser Zone weitergeleitet werden." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "40", + "Thema": "Informationen", + "Kurztext": "", + "Titel": "Datenbekanntgabe an Dritte", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Im Rahmen der Bearbeitung der Log-Daten durch einen Auftragsbearbeiter dürfen keine Daten an Dritte bekanntgegeben werden, sofern dies nicht zwingend erforderlich ist." + }, + { + "typ": "text", + "inhalt": "Die Bekanntgabe von Daten an Dritte (z.B. Unterauftragnehmer) darf nur unter der vorgängigen Genehmigung des Dateninhabers erfolgen. Dies betrifft sowohl die Log-Datensammlung selbst als auch allfällige Metadaten, die mit der Log-Datensammlung verknüpft sind oder davon abgeleitet werden können." + }, + { + "typ": "text", + "inhalt": "Die Bekanntgabe von Log-Daten an Dritte darf nur erfolgen, falls die Bekanntgabe für die Zweckerfüllung der Bearbeitung zwingend erforderlich ist." + }, + { + "typ": "text", + "inhalt": "Die Bekanntgabe von Log-Daten an Dritte darf keine negativen Auswirkungen auf die Schutzziele Vertraulichkeit, Integrität, Verfügbarkeit und Nachvollziehbarkeit haben." + }, + { + "typ": "text", + "inhalt": "Werden Log-Daten an Dritte bekanntgegeben, bzw. durch Dritte bearbeitet, muss diese Bearbeitung vertraglich mit dem Verantwortlichen und Auftragsbearbeiter geregelt werden. Der Dateninhaber muss sich dabei vergewissern, dass die Sicherheit der Log-Daten bei ihrer Bearbeitung weiterhin gewährleistet wird." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "41", + "Thema": "Informationen", + "Kurztext": "", + "Titel": "Physische Trennung", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Log-Daten dürfen nicht von derjenigen Person manipuliert oder gelöscht werden können, deren Aktivitäten als direkte Konsequenz die Erzeugung dieser Log-Daten hatte. Hierzu müssen angemessene technische und organisatorische Massnahmen umgesetzt werden. Die umgesetzten Massnahmen sind schriftlich zu dokumentieren." + }, + { + "typ": "text", + "inhalt": "Sollte das nicht möglich sein, sind die Anforderungen *R066.5.12 Physische Trennung* und *R066.5.13 Erkennung von Manipulationen* zwingend einzuhalten." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + }, + { + "Nummer": "42", + "Thema": "Informationen", + "Titel": "Erkennung von Manipulationen", + "Kurztext": "", + "Langtext": { + "Abschnitt": [ + { + "typ": "text", + "inhalt": "Allfällige Manipulationen von Log-Daten müssen erkennbar und nachvollziehbar sein. Falls ein System weder schreibgeschützte Log-Daten (R066.5.10), Separation of Duties (R066.5.11) oder physische Trennung (R066.5.12) ermöglicht, ist diese Anforderung zwingend einzuhalten." + }, + { + "typ": "text", + "inhalt": "Für Log-Daten, die nicht gegen unberechtigte Manipulationen oder Löschungen geschützt werden können, muss auf jeden Fall das Schutzziel der Nachvollziehbarkeit erreicht werden. D.h., dass es festgestellt werden muss, ob die Daten manipuliert oder gelöscht wurden, und falls ja, von wem." + }, + { + "typ": "text", + "inhalt": "Die anfallenden Daten müssen mittels einer kryptografischen Hashfunktion geschützt werden. Der Hashwert (Fingerprint) soll auf einem anderen System als demjenigen, auf welchem die Logs erzeugt wurden zeitnah erstellt werden." + }, + { + "typ": "text", + "inhalt": "Die Hashwerte sollen nicht mit dem gleichen technischen User erstellt werden, welche die Log-Daten entgegen nimmt/transferiert." + } + ] + }, + "Referenz": [ + "IT-Grundschutz I2" + ], + "Gueltigkeit": { + "Von": "2024-01-01", + "Bis": null + }, + "Checklistenfragen": [ + "" + ], + "Stichworte": [] + } + ] + } +} \ No newline at end of file diff --git a/Test Suite-DE.md b/Test Suite-DE.md new file mode 100644 index 0000000..386bb52 --- /dev/null +++ b/Test Suite-DE.md @@ -0,0 +1,369 @@ +# Test-Suite Dokumentation + +Dieses Dokument bietet einen umfassenden Überblick über alle Tests im vgui-cicd Django-Projekt und beschreibt, was jeder Test tut und wie er funktioniert. + +## Inhaltsverzeichnis + +- [abschnitte App Tests](#abschnitte-app-tests) +- [dokumente App Tests](#dokumente-app-tests) +- [pages App Tests](#pages-app-tests) +- [referenzen App Tests](#referenzen-app-tests) +- [rollen App Tests](#rollen-app-tests) +- [stichworte App Tests](#stichworte-app-tests) + +--- + +## abschnitte App Tests + +Die abschnitte App enthält 32 Tests, die Modelle, Utility-Funktionen, Diagram-Caching und Management-Befehle abdecken. + +### Modell-Tests + +#### AbschnittTypModelTest +- **test_abschnitttyp_creation**: Überprüft, dass AbschnittTyp-Objekte korrekt mit den erwarteten Feldwerten erstellt werden +- **test_abschnitttyp_primary_key**: Bestätigt, dass das `abschnitttyp`-Feld als Primärschlüssel dient +- **test_abschnitttyp_str**: Testet die String-Repräsentation, die den `abschnitttyp`-Wert zurückgibt +- **test_abschnitttyp_verbose_name_plural**: Validiert den korrekt gesetzten verbose_name_plural +- **test_create_multiple_abschnitttypen**: Stellt sicher, dass mehrere AbschnittTyp-Objekte mit verschiedenen Typen erstellt werden können + +#### TextabschnittModelTest +- **test_textabschnitt_creation**: Testet, dass Textabschnitt über das konkrete Modell instanziiert werden kann +- **test_textabschnitt_default_order**: Überprüft, dass das `order`-Feld standardmäßig 0 ist +- **test_textabschnitt_ordering**: Testet, dass Textabschnitt-Objekte nach dem `order`-Feld sortiert werden können +- **test_textabschnitt_blank_fields**: Bestätigt, dass `abschnitttyp`- und `inhalt`-Felder leer/null sein können +- **test_textabschnitt_foreign_key_protection**: Testet, dass AbschnittTyp-Objekte vor Löschung geschützt sind, wenn sie von Textabschnitt referenziert werden + +### Utility-Funktions-Tests + +#### MdTableToHtmlTest +- **test_simple_table**: Konvertiert eine einfache Markdown-Tabelle mit Überschriften und einer Zeile nach HTML +- **test_table_with_multiple_rows**: Testet die Konvertierung von Tabellen mit mehreren Datenzeilen +- **test_table_with_empty_cells**: Verarbeitet Tabellen mit leeren Zellen in den Daten +- **test_table_with_spaces**: Verarbeitet Tabellen mit zusätzlichen Leerzeichen in Zellen +- **test_table_empty_string**: Löst ValueError für leere Eingabe-Strings aus +- **test_table_only_whitespace**: Löst ValueError für Strings aus, die nur Leerzeichen enthalten +- **test_table_insufficient_lines**: Löst ValueError aus, wenn die Eingabe weniger als 2 Zeilen hat + +#### RenderTextabschnitteTest +- **test_render_empty_queryset**: Gibt leeren String für leere Querysets zurück +- **test_render_multiple_abschnitte**: Rendert mehrere Textabschnitte in korrekter Reihenfolge +- **test_render_text_markdown**: Konvertiert Klartext mit Markdown-Formatierung +- **test_render_ordered_list**: Rendert geordnete Listen korrekt +- **test_render_unordered_list**: Rendert ungeordnete Listen korrekt +- **test_render_code_block**: Rendert Code-Blöcke mit korrekter Syntax-Hervorhebung +- **test_render_table**: Konvertiert Markdown-Tabellen mit md_table_to_html nach HTML +- **test_render_diagram_success**: Testet die Diagramm-Generierung mit erfolgreichem Caching +- **test_render_diagram_error**: Behandelt Diagramm-Generierungsfehler angemessen +- **test_render_diagram_with_options**: Testet das Diagramm-Rendering mit benutzerdefinierten Optionen +- **test_render_text_with_footnotes**: Verarbeitet Text, der Fußnoten enthält +- **test_render_abschnitt_without_type**: Behandelt Textabschnitte ohne AbschnittTyp +- **test_render_abschnitt_with_empty_content**: Behandelt Textabschnitte mit leerem Inhalt + +### Diagram-Caching-Tests + +#### DiagramCacheTest +- **test_compute_hash**: Generiert konsistente SHA256-Hashes für dieselbe Eingabe +- **test_get_cache_path**: Erstellt korrekte Cache-Dateipfade basierend auf Hash und Typ +- **test_get_cached_diagram_hit**: Gibt zwischengespeichertes Diagramm zurück bei Cache-Treffer +- **test_get_cached_diagram_miss**: Generiert neues Diagramm bei Cache-Fehltreffer +- **test_get_cached_diagram_request_error**: Behandelt und löst Request-Fehler korrekt aus +- **test_clear_cache_specific_type**: Löscht Cache-Dateien für spezifische Diagrammtypen +- **test_clear_cache_all_types**: Löscht alle Cache-Dateien, wenn kein Typ angegeben ist + +### Management-Befehl-Tests + +#### ClearDiagramCacheCommandTest +- **test_command_without_type**: Testet die Ausführung des Management-Befehls ohne Angabe des Typs +- **test_command_with_type**: Testet die Ausführung des Management-Befehls mit spezifischem Diagrammtyp + +### Integrations-Tests + +#### IntegrationTest +- **test_textabschnitt_inheritance**: Überprüft, dass VorgabeLangtext Textabschnitt-Felder korrekt erbt +- **test_render_vorgabe_langtext**: Testet das Rendern von VorgabeLangtext durch render_textabschnitte + +--- + +## dokumente App Tests + +Die dokumente App enthält 98 Tests und ist damit die umfassendste Test-Suite, die alle Modelle, Views, URLs und Geschäftslogik abdeckt. + +### Modell-Tests + +#### DokumententypModelTest +- **test_dokumententyp_creation**: Überprüft die Erstellung von Dokumententyp mit korrekten Feldwerten +- **test_dokumententyp_str**: Testet die String-Repräsentation, die das `typ`-Feld zurückgibt +- **test_dokumententyp_verbose_name**: Validiert den korrekt gesetzten verbose_name + +#### PersonModelTest +- **test_person_creation**: Testet die Erstellung von Person-Objekten mit Name und optionalem Titel +- **test_person_str**: Überprüft, dass die String-Repräsentation Titel und Namen enthält +- **test_person_verbose_name_plural**: Testet die Konfiguration von verbose_name_plural + +#### ThemaModelTest +- **test_thema_creation**: Testet die Erstellung von Thema mit Name und optionaler Erklärung +- **test_thema_str**: Überprüft, dass die String-Repräsentation den Themennamen zurückgibt +- **test_thema_blank_erklaerung**: Bestätigt, dass das `erklaerung`-Feld leer sein kann + +#### DokumentModelTest +- **test_dokument_creation**: Testet die Erstellung von Dokument mit erforderlichen und optionalen Feldern +- **test_dokument_str**: Überprüft, dass die String-Repräsentation den Dokumenttitel zurückgibt +- **test_dokument_optional_fields**: Testet, dass optionale Felder None oder leer sein können +- **test_dokument_many_to_many_relationships**: Überprüft Many-to-Many-Beziehungen mit Personen und Themen + +#### VorgabeModelTest +- **test_vorgabe_creation**: Testet die Erstellung von Vorgabe mit allen erforderlichen Feldern +- **test_vorgabe_str**: Überprüft, dass die String-Repräsentation die Vorgabennummer zurückgibt +- **test_vorgabennummer**: Testet die automatische Generierung des Vorgabennummer-Formats +- **test_get_status_active**: Testet die Statusbestimmung für aktuelle aktive Vorgaben +- **test_get_status_expired**: Testet die Statusbestimmung für abgelaufene Vorgaben +- **test_get_status_future**: Testet die Statusbestimmung für zukünftige Vorgaben +- **test_get_status_with_custom_check_date**: Testet den Status mit benutzerdefiniertem Prüfdatum +- **test_get_status_verbose**: Testet die ausführliche Statusausgabe + +#### ChangelogModelTest +- **test_changelog_creation**: Testet die Erstellung von Changelog mit Version, Datum und Beschreibung +- **test_changelog_str**: Überprüft, dass die String-Repräsentation Version und Datum enthält + +#### ChecklistenfrageModelTest +- **test_checklistenfrage_creation**: Testet die Erstellung von Checklistenfrage mit Frage und optionaler Antwort +- **test_checklistenfrage_str**: Überprüft, dass die String-Repräsentation lange Fragen kürzt +- **test_checklistenfrage_related_name**: Testet die umgekehrte Beziehung von Vorgabe + +### Text-Abschnitt-Tests + +#### DokumentTextAbschnitteTest +- **test_einleitung_creation**: Testet die Erstellung von Einleitung und Vererbung von Textabschnitt +- **test_geltungsbereich_creation**: Testet die Erstellung von Geltungsbereich und Vererbung + +#### VorgabeTextAbschnitteTest +- **test_vorgabe_kurztext_creation**: Testet die Erstellung von VorgabeKurztext und Vererbung +- **test_vorgabe_langtext_creation**: Testet die Erstellung von VorgabeLangtext und Vererbung + +### Sanity-Check-Tests + +#### VorgabeSanityCheckTest +- **test_date_ranges_intersect_no_overlap**: Testet Datumsüberschneidung mit nicht überlappenden Bereichen +- **test_date_ranges_intersect_with_overlap**: Testet Datumsüberschneidung mit überlappenden Bereichen +- **test_date_ranges_intersect_identical_ranges**: Testet Datumsüberschneidung mit identischen Bereichen +- **test_date_ranges_intersect_with_none_end_date**: Testet Überschneidung mit offenen Endbereichen +- **test_date_ranges_intersect_both_none_end_dates**: Testet Überschneidung mit zwei offenen Endbereichen +- **test_check_vorgabe_conflicts_utility**: Testet die Utility-Funktion zur Konflikterkennung +- **test_find_conflicts_no_conflicts**: Testet die Konflikterkennung bei Vorgabe ohne Konflikte +- **test_find_conflicts_with_conflicts**: Testet die Konflikterkennung mit konfliktbehafteten Vorgaben +- **test_format_conflict_report_no_conflicts**: Testet die Konfliktbericht-Formatierung ohne Konflikte +- **test_format_conflict_report_with_conflicts**: Testet die Konfliktbericht-Formatierung mit Konflikten +- **test_sanity_check_vorgaben_no_conflicts**: Testet vollständigen Sanity-Check ohne Konflikte +- **test_sanity_check_vorgaben_with_conflicts**: Testet vollständigen Sanity-Check mit Konflikten +- **test_sanity_check_vorgaben_multiple_conflicts**: Testet Sanity-Check mit mehreren Konfliktgruppen +- **test_vorgabe_clean_no_conflicts**: Testet Vorgabe.clean()-Methode ohne Konflikte +- **test_vorgabe_clean_with_conflicts**: Testet, dass Vorgabe.clean() ValidationError bei Konflikten auslöst + +### Management-Befehl-Tests + +#### SanityCheckManagementCommandTest +- **test_sanity_check_command_no_conflicts**: Testet Management-Befehlsausgabe ohne Konflikte +- **test_sanity_check_command_with_conflicts**: Testet Management-Befehlsausgabe mit Konflikten + +### URL-Pattern-Tests + +#### URLPatternsTest +- **test_standard_list_url_resolves**: Überprüft, dass standard_list URL zur korrekten View aufgelöst wird +- **test_standard_detail_url_resolves**: Überprüft, dass standard_detail URL mit pk-Parameter aufgelöst wird +- **test_standard_history_url_resolves**: Überprüft, dass standard_history URL mit check_date aufgelöst wird +- **test_standard_checkliste_url_resolves**: Überprüft, dass standard_checkliste URL mit pk aufgelöst wird + +### View-Tests + +#### ViewsTestCase +- **test_standard_list_view**: Testet, dass die Standard-Listen-View 200 zurückgibt und erwartete Inhalte enthält +- **test_standard_detail_view**: Testet die Standard-Detail-View mit existierendem Dokument +- **test_standard_detail_view_404**: Testet, dass die Standard-Detail-View 404 für nicht existierendes Dokument zurückgibt +- **test_standard_history_view**: Testet die Standard-Detail-View mit historischem check_date-Parameter +- **test_standard_checkliste_view**: Testet die Funktionalität der Checklisten-View + +### JSON-Export-Tests + +#### JSONExportManagementCommandTest +- **test_export_json_command_to_file**: Testet, dass der export_json-Befehl JSON in die angegebene Datei ausgibt +- **test_export_json_command_stdout**: Testet, dass der export_json-Befehl JSON an stdout ausgibt, wenn keine Datei angegeben ist +- **test_export_json_command_inactive_documents**: Testet, dass der export_json-Befehl inaktive Dokumente herausfiltert +- **test_export_json_command_empty_database**: Testet, dass der export_json-Befehl leere Datenbank angemessen behandelt + +#### StandardJSONViewTest +- **test_standard_json_view_success**: Testet, dass die standard_json-View korrektes JSON für existierendes Dokument zurückgibt +- **test_standard_json_view_not_found**: Testet, dass die standard_json-View 404 für nicht existierendes Dokument zurückgibt +- **test_standard_json_view_json_formatting**: Testet, dass die standard_json-View korrekt formatiertes JSON zurückgibt +- **test_standard_json_view_null_dates**: Testet, dass die standard_json-View null-Datumfelder korrekt behandelt +- **test_standard_json_view_empty_sections**: Testet, dass die standard_json-View leere Dokumentabschnitte behandelt + +### Unvollständige Vorgaben Tests + +#### IncompleteVorgabenTest +- **test_incomplete_vorgaben_page_status**: Testet, dass die Seite erfolgreich lädt (200-Status) +- **test_incomplete_vorgaben_staff_only**: Testet, dass Nicht-Staff-Benutzer zum Login weitergeleitet werden +- **test_incomplete_vorgaben_page_content**: Testet, dass die Seite erwartete Überschriften und Struktur enthält +- **test_navigation_link**: Testet, dass die Navigation einen Link zur unvollständigen Vorgaben-Seite enthält +- **test_no_references_list**: Testet, dass Vorgaben ohne Referenzen korrekt aufgelistet werden +- **test_no_stichworte_list**: Testet, dass Vorgaben ohne Stichworte korrekt aufgelistet werden +- **test_no_text_list**: Testet, dass Vorgaben ohne Kurz- oder Langtext korrekt aufgelistet werden +- **test_no_checklistenfragen_list**: Testet, dass Vorgaben ohne Checklistenfragen korrekt aufgelistet werden +- **test_vorgabe_with_both_text_types**: Testet, dass Vorgabe mit beiden Texttypen als vollständig betrachtet wird +- **test_vorgabe_with_langtext_only**: Testet, dass Vorgabe mit nur Langtext immer noch unvollständig für Text ist +- **test_empty_lists_message**: Testet angemessene Nachrichten, wenn Listen leer sind +- **test_badge_counts**: Testet, dass Badge-Zähler korrekt berechnet werden +- **test_summary_section**: Testet, dass die Zusammenfassungssektion korrekte Zähler anzeigt +- **test_vorgabe_links**: Testet, dass Vorgaben zu korrekten Admin-Seiten verlinken +- **test_back_link**: Testet, dass der Zurück-Link zur Standardübersicht existiert + +--- + +## pages App Tests + +Die pages App enthält 4 Tests, die sich auf die Suchfunktionalität und Validierung konzentrieren. + +### ViewsTestCase +- **test_search_view_get**: Testet GET-Anfrage an die Search-View gibt 200-Status zurück +- **test_search_view_post_with_query**: Testet POST-Anfrage mit Query gibt Ergebnisse zurück +- **test_search_view_post_empty_query**: Testet POST-Anfrage mit leerer Query zeigt Validierungsfehler +- **test_search_view_post_no_query**: Testet POST-Anfrage ohne Query-Parameter zeigt Validierungsfehler + +--- + +## referenzen App Tests + +Die referenzen App enthält 18 Tests, die sich auf MPTT-Hierarchiefunktionalität und Modellbeziehungen konzentrieren. + +### Modell-Tests + +#### ReferenzModelTest +- **test_referenz_creation**: Testet die Erstellung von Referenz mit erforderlichen Feldern +- **test_referenz_str**: Testet die String-Repräsentation gibt den Referenztext zurück +- **test_referenz_ordering**: Testet die Standard-Sortierung nach `order`-Feld +- **test_referenz_optional_fields**: Testet, dass optionale Felder leer sein können + +#### ReferenzerklaerungModelTest +- **test_referenzerklaerung_creation**: Testet die Erstellung von Referenzerklaerung mit Referenz und Erklärung +- **test_referenzerklaerung_str**: Testet die String-Repräsentation enthält Referenz und Erklärungsvorschau +- **test_referenzerklaerung_ordering**: Testet die Standard-Sortierung nach `order`-Feld +- **test_referenzerklaerung_optional_explanation**: Testet, dass das Erklärungsfeld leer sein kann + +### Hierarchie-Tests + +#### ReferenzHierarchyTest +- **test_hierarchy_relationships**: Testet Eltern-Kind-Beziehungen im MPTT-Baum +- **test_get_root**: Testet das Abrufen des Wurzelknotens einer Hierarchie +- **test_get_children**: Testet das Abrufen direkter Kinder eines Knotens +- **test_get_descendants**: Testet das Abrufen aller Nachkommen eines Knotens +- **test_get_ancestors**: Testet das Abrufen aller Vorfahren eines Knotens +- **test_get_ancestors_include_self**: Testet das Abrufen von Vorfahren einschließlich des Knotens selbst +- **test_is_leaf_node**: Testet die Erkennung von Blattknoten +- **test_is_root_node**: Testet die Erkennung von Wurzelknoten +- **test_tree_ordering**: Testet die Baum-Sortierung mit mehreren Ebenen +- **test_move_node**: Testet das Verschieben von Knoten innerhalb der Baumstruktur + +--- + +## rollen App Tests + +Die rollen App enthält 18 Tests, die Rollenmodelle und ihre Beziehungen zu Dokumentabschnitten abdecken. + +### Modell-Tests + +#### RolleModelTest +- **test_rolle_creation**: Testet die Erstellung von Rolle mit Name und optionaler Beschreibung +- **test_rolle_str**: Testet die String-Repräsentation gibt den Rollennamen zurück +- **test_rolle_ordering**: Testet die Standard-Sortierung nach `order`-Feld +- **test_rolle_unique_name**: Testet, dass Rollennamen einzigartig sein müssen +- **test_rolle_optional_beschreibung**: Testet, dass das Beschreibungsfeld leer sein kann + +#### RollenBeschreibungModelTest +- **test_rollenbeschreibung_creation**: Testet die Erstellung von RollenBeschreibung mit Rolle und Abschnittstyp +- **test_rollenbeschreibung_str**: Testet die String-Repräsentation enthält Rolle und Abschnittstyp +- **test_rollenbeschreibung_ordering**: Testet die Standard-Sortierung nach `order`-Feld +- **test_rollenbeschreibung_unique_combination**: Testet die Unique-Constraint auf Rolle und Abschnittstyp +- **test_rollenbeschreibung_optional_beschreibung**: Testet, dass das Beschreibungsfeld leer sein kann + +### Beziehungs-Tests + +#### RelationshipTest +- **test_rolle_rollenbeschreibung_relationship**: Testet die Eins-zu-viele-Beziehung zwischen Rolle und RollenBeschreibung +- **test_abschnitttyp_rollenbeschreibung_relationship**: Testet die Beziehung zwischen AbschnittTyp und RollenBeschreibung +- **test_cascade_delete**: Testet das Cascade-Delete-Verhalten beim Löschen einer Rolle +- **test_protected_delete**: Testet das Protected-Delete-Verhalten, wenn Abschnittstyp referenziert wird +- **test_query_related_objects**: Testet das effiziente Abfragen verwandter Objekte +- **test_string_representations**: Testet, dass alle String-Repräsentationen korrekt funktionieren +- **test_ordering_consistency**: Testet, dass die Sortierung über Abfragen hinweg konsistent ist + +--- + +## stichworte App Tests + +Die stichworte App enthält 18 Tests, die Schlüsselwortmodelle und ihre Sortierung abdecken. + +### Modell-Tests + +#### StichwortModelTest +- **test_stichwort_creation**: Testet die Erstellung von Stichwort mit Schlüsselworttext +- **test_stichwort_str**: Testet die String-Repräsentation gibt den Schlüsselworttext zurück +- **test_stichwort_ordering**: Testet die Standard-Sortierung nach `stichwort`-Feld +- **test_stichwort_unique**: Testet, dass Schlüsselwörter einzigartig sein müssen +- **test_stichwort_case_insensitive**: Testet die Groß-/Kleinschreibungs-unabhängige Eindeutigkeit + +#### StichworterklaerungModelTest +- **test_stichworterklaerung_creation**: Testet die Erstellung von Stichworterklaerung mit Schlüsselwort und Erklärung +- **test_stichworterklaerung_str**: Testet die String-Repräsentation enthält Schlüsselwort und Erklärungsvorschau +- **test_stichworterklaerung_ordering**: Testet die Standard-Sortierung nach `order`-Feld +- **test_stichworterklaerung_optional_erklaerung**: Testet, dass das Erklärungsfeld leer sein kann +- **test_stichworterklaerung_unique_stichwort**: Testet den Unique-Constraint auf das Schlüsselwort + +### Beziehungs-Tests + +#### RelationshipTest +- **test_stichwort_stichworterklaerung_relationship**: Testet die Eins-zu-eins-Beziehung zwischen Stichwort und Stichworterklaerung +- **test_cascade_delete**: Testet das Cascade-Delete-Verhalten beim Löschen eines Schlüsselworts +- **test_protected_delete**: Testet das Protected-Delete-Verhalten, wenn Erklärung referenziert wird +- **test_query_related_objects**: Testet das effiziente Abfragen verwandter Objekte +- **test_string_representations**: Testet, dass alle String-Repräsentationen korrekt funktionieren +- **test_ordering_consistency**: Testet, dass die Sortierung über Abfragen hinweg konsistent ist +- **test_reverse_relationship**: Testet die umgekehrte Beziehung von Erklärung zu Schlüsselwort + +--- + +## Test-Statistiken + +- **Gesamt-Tests**: 206 +- **abschnitte**: 32 Tests +- **dokumente**: 116 Tests (98 in tests.py + 9 in test_json.py + 9 JSON-Tests in Haupt-tests.py) +- **pages**: 4 Tests +- **referenzen**: 18 Tests +- **rollen**: 18 Tests +- **stichworte**: 18 Tests + +## Test-Abdeckungsbereiche + +1. **Modell-Validierung**: Feldvalidierung, Constraints und Beziehungen +2. **Geschäftslogik**: Statusbestimmung, Konflikterkennung, Hierarchieverwaltung +3. **View-Funktionalität**: HTTP-Antworten, Template-Rendering, URL-Auflösung +4. **Utility-Funktionen**: Textverarbeitung, Caching, Formatierung +5. **Management-Befehle**: CLI-Schnittstelle und Ausgabeverarbeitung +6. **Integration**: App-übergreifende Funktionalität und Datenfluss + +## Ausführen der Tests + +Um alle Tests auszuführen: +```bash +python manage.py test +``` + +Um Tests für eine spezifische App auszuführen: +```bash +python manage.py test app_name +``` + +Um mit ausführlicher Ausgabe auszuführen: +```bash +python manage.py test --verbosity=2 +``` + +Alle Tests laufen derzeit erfolgreich und bieten umfassende Abdeckung der Funktionalität der Anwendung. \ No newline at end of file diff --git a/Test suite.md b/Test suite.md new file mode 100644 index 0000000..f3f33ee --- /dev/null +++ b/Test suite.md @@ -0,0 +1,369 @@ +# Test Suite Documentation + +This document provides a comprehensive overview of all tests in the vgui-cicd Django project, describing what each test does and how it works. + +## Table of Contents + +- [abschnitte App Tests](#abschnitte-app-tests) +- [dokumente App Tests](#dokumente-app-tests) +- [pages App Tests](#pages-app-tests) +- [referenzen App Tests](#referenzen-app-tests) +- [rollen App Tests](#rollen-app-tests) +- [stichworte App Tests](#stichworte-app-tests) + +--- + +## abschnitte App Tests + +The abschnitte app contains 32 tests covering models, utility functions, diagram caching, and management commands. + +### Model Tests + +#### AbschnittTypModelTest +- **test_abschnitttyp_creation**: Verifies that AbschnittTyp objects are created correctly with the expected field values +- **test_abschnitttyp_primary_key**: Confirms that the `abschnitttyp` field serves as the primary key +- **test_abschnitttyp_str**: Tests the string representation returns the `abschnitttyp` value +- **test_abschnitttyp_verbose_name_plural**: Validates the verbose name plural is set correctly +- **test_create_multiple_abschnitttypen**: Ensures multiple AbschnittTyp objects can be created with different types + +#### TextabschnittModelTest +- **test_textabschnitt_creation**: Tests that Textabschnitt can be instantiated through the concrete model +- **test_textabschnitt_default_order**: Verifies the `order` field defaults to 0 +- **test_textabschnitt_ordering**: Tests that Textabschnitt objects can be ordered by the `order` field +- **test_textabschnitt_blank_fields**: Confirms that `abschnitttyp` and `inhalt` fields can be blank/null +- **test_textabschnitt_foreign_key_protection**: Tests that AbschnittTyp objects are protected from deletion when referenced by Textabschnitt + +### Utility Function Tests + +#### MdTableToHtmlTest +- **test_simple_table**: Converts a basic markdown table with headers and one row to HTML +- **test_table_with_multiple_rows**: Tests conversion of tables with multiple data rows +- **test_table_with_empty_cells**: Handles tables with empty cells in the data +- **test_table_with_spaces**: Processes tables with extra spaces in cells +- **test_table_empty_string**: Raises ValueError for empty input strings +- **test_table_only_whitespace**: Raises ValueError for strings containing only whitespace +- **test_table_insufficient_lines**: Raises ValueError when input has fewer than 2 lines + +#### RenderTextabschnitteTest +- **test_render_empty_queryset**: Returns empty string for empty querysets +- **test_render_multiple_abschnitte**: Renders multiple Textabschnitte in correct order +- **test_render_text_markdown**: Converts plain text with markdown formatting +- **test_render_ordered_list**: Renders ordered lists correctly +- **test_render_unordered_list**: Renders unordered lists correctly +- **test_render_code_block**: Renders code blocks with proper syntax highlighting +- **test_render_table**: Converts markdown tables to HTML using md_table_to_html +- **test_render_diagram_success**: Tests diagram generation with successful caching +- **test_render_diagram_error**: Handles diagram generation errors gracefully +- **test_render_diagram_with_options**: Tests diagram rendering with custom options +- **test_render_text_with_footnotes**: Processes text containing footnotes +- **test_render_abschnitt_without_type**: Handles Textabschnitte without AbschnittTyp +- **test_render_abschnitt_with_empty_content**: Handles Textabschnitte with empty content + +### Diagram Caching Tests + +#### DiagramCacheTest +- **test_compute_hash**: Generates consistent SHA256 hashes for the same input +- **test_get_cache_path**: Creates correct cache file paths based on hash and type +- **test_get_cached_diagram_hit**: Returns cached diagram when cache hit occurs +- **test_get_cached_diagram_miss**: Generates new diagram when cache miss occurs +- **test_get_cached_diagram_request_error**: Properly handles and raises request errors +- **test_clear_cache_specific_type**: Clears cache files for specific diagram types +- **test_clear_cache_all_types**: Clears all cache files when no type specified + +### Management Command Tests + +#### ClearDiagramCacheCommandTest +- **test_command_without_type**: Tests management command execution without specifying type +- **test_command_with_type**: Tests management command execution with specific diagram type + +### Integration Tests + +#### IntegrationTest +- **test_textabschnitt_inheritance**: Verifies VorgabeLangtext properly inherits Textabschnitt fields +- **test_render_vorgabe_langtext**: Tests rendering VorgabeLangtext through render_textabschnitte + +--- + +## dokumente App Tests + +The dokumente app contains 98 tests, making it the most comprehensive test suite, covering all models, views, URLs, and business logic. + +### Model Tests + +#### DokumententypModelTest +- **test_dokumententyp_creation**: Verifies Dokumententyp creation with correct field values +- **test_dokumententyp_str**: Tests string representation returns the `typ` field +- **test_dokumententyp_verbose_name**: Validates verbose name is set correctly + +#### PersonModelTest +- **test_person_creation**: Tests Person object creation with name and optional title +- **test_person_str**: Verifies string representation includes title and name +- **test_person_verbose_name_plural**: Tests verbose name plural configuration + +#### ThemaModelTest +- **test_thema_creation**: Tests Thema creation with name and optional explanation +- **test_thema_str**: Verifies string representation returns the theme name +- **test_thema_blank_erklaerung**: Confirms `erklaerung` field can be blank + +#### DokumentModelTest +- **test_dokument_creation**: Tests Dokument creation with required and optional fields +- **test_dokument_str**: Verifies string representation returns the document title +- **test_dokument_optional_fields**: Tests that optional fields can be None or blank +- **test_dokument_many_to_many_relationships**: Verifies many-to-many relationships with Personen and Themen + +#### VorgabeModelTest +- **test_vorgabe_creation**: Tests Vorgabe creation with all required fields +- **test_vorgabe_str**: Verifies string representation returns the Vorgabennummer +- **test_vorgabennummer**: Tests automatic generation of Vorgabennummer format +- **test_get_status_active**: Tests status determination for current active Vorgaben +- **test_get_status_expired**: Tests status determination for expired Vorgaben +- **test_get_status_future**: Tests status determination for future Vorgaben +- **test_get_status_with_custom_check_date**: Tests status with custom check date +- **test_get_status_verbose**: Tests verbose status output + +#### ChangelogModelTest +- **test_changelog_creation**: Tests Changelog creation with version, date, and description +- **test_changelog_str**: Verifies string representation includes version and date + +#### ChecklistenfrageModelTest +- **test_checklistenfrage_creation**: Tests Checklistenfrage creation with question and optional answer +- **test_checklistenfrage_str**: Verifies string representation truncates long questions +- **test_checklistenfrage_related_name**: Tests the reverse relationship from Vorgabe + +### Text Abschnitt Tests + +#### DokumentTextAbschnitteTest +- **test_einleitung_creation**: Tests Einleitung creation and inheritance from Textabschnitt +- **test_geltungsbereich_creation**: Tests Geltungsbereich creation and inheritance + +#### VorgabeTextAbschnitteTest +- **test_vorgabe_kurztext_creation**: Tests VorgabeKurztext creation and inheritance +- **test_vorgabe_langtext_creation**: Tests VorgabeLangtext creation and inheritance + +### Sanity Check Tests + +#### VorgabeSanityCheckTest +- **test_date_ranges_intersect_no_overlap**: Tests date intersection with non-overlapping ranges +- **test_date_ranges_intersect_with_overlap**: Tests date intersection with overlapping ranges +- **test_date_ranges_intersect_identical_ranges**: Tests date intersection with identical ranges +- **test_date_ranges_intersect_with_none_end_date**: Tests intersection with open-ended ranges +- **test_date_ranges_intersect_both_none_end_dates**: Tests intersection with two open-ended ranges +- **test_check_vorgabe_conflicts_utility**: Tests the utility function for conflict detection +- **test_find_conflicts_no_conflicts**: Tests conflict detection on Vorgabe without conflicts +- **test_find_conflicts_with_conflicts**: Tests conflict detection with conflicting Vorgaben +- **test_format_conflict_report_no_conflicts**: Tests conflict report formatting with no conflicts +- **test_format_conflict_report_with_conflicts**: Tests conflict report formatting with conflicts +- **test_sanity_check_vorgaben_no_conflicts**: Tests full sanity check with no conflicts +- **test_sanity_check_vorgaben_with_conflicts**: Tests full sanity check with conflicts +- **test_sanity_check_vorgaben_multiple_conflicts**: Tests sanity check with multiple conflict groups +- **test_vorgabe_clean_no_conflicts**: Tests Vorgabe.clean() method without conflicts +- **test_vorgabe_clean_with_conflicts**: Tests Vorgabe.clean() raises ValidationError with conflicts + +### Management Command Tests + +#### SanityCheckManagementCommandTest +- **test_sanity_check_command_no_conflicts**: Tests management command output with no conflicts +- **test_sanity_check_command_with_conflicts**: Tests management command output with conflicts + +### URL Pattern Tests + +#### URLPatternsTest +- **test_standard_list_url_resolves**: Verifies standard_list URL resolves to correct view +- **test_standard_detail_url_resolves**: Verifies standard_detail URL resolves with pk parameter +- **test_standard_history_url_resolves**: Verifies standard_history URL resolves with check_date +- **test_standard_checkliste_url_resolves**: Verifies standard_checkliste URL resolves with pk + +### View Tests + +#### ViewsTestCase +- **test_standard_list_view**: Tests standard list view returns 200 and contains expected content +- **test_standard_detail_view**: Tests standard detail view with existing document +- **test_standard_detail_view_404**: Tests standard detail view returns 404 for non-existent document +- **test_standard_history_view**: Tests standard detail view with historical check_date parameter +- **test_standard_checkliste_view**: Tests checklist view functionality + +### JSON Export Tests + +#### JSONExportManagementCommandTest +- **test_export_json_command_to_file**: Tests export_json command outputs JSON to specified file +- **test_export_json_command_stdout**: Tests export_json command outputs JSON to stdout when no file specified +- **test_export_json_command_inactive_documents**: Tests export_json command filters out inactive documents +- **test_export_json_command_empty_database**: Tests export_json command handles empty database gracefully + +#### StandardJSONViewTest +- **test_standard_json_view_success**: Tests standard_json view returns correct JSON for existing document +- **test_standard_json_view_not_found**: Tests standard_json view returns 404 for non-existent document +- **test_standard_json_view_json_formatting**: Tests standard_json view returns properly formatted JSON +- **test_standard_json_view_null_dates**: Tests standard_json view handles null date fields correctly +- **test_standard_json_view_empty_sections**: Tests standard_json view handles empty document sections + +### Incomplete Vorgaben Tests + +#### IncompleteVorgabenTest +- **test_incomplete_vorgaben_page_status**: Tests page loads successfully (200 status) +- **test_incomplete_vorgaben_staff_only**: Tests non-staff users are redirected to login +- **test_incomplete_vorgaben_page_content**: Tests page contains expected headings and structure +- **test_navigation_link**: Tests navigation includes link to incomplete Vorgaben page +- **test_no_references_list**: Tests Vorgaben without references are listed correctly +- **test_no_stichworte_list**: Tests Vorgaben without Stichworte are listed correctly +- **test_no_text_list**: Tests Vorgaben without Kurz- or Langtext are listed correctly +- **test_no_checklistenfragen_list**: Tests Vorgaben without Checklistenfragen are listed correctly +- **test_vorgabe_with_both_text_types**: Tests Vorgabe with both text types is considered complete +- **test_vorgabe_with_langtext_only**: Tests Vorgabe with only Langtext is still incomplete for text +- **test_empty_lists_message**: Tests appropriate messages when lists are empty +- **test_badge_counts**: Tests badge counts are calculated correctly +- **test_summary_section**: Tests summary section shows correct counts +- **test_vorgabe_links**: Tests Vorgaben link to correct admin pages +- **test_back_link**: Tests back link to standard list exists + +--- + +## pages App Tests + +The pages app contains 4 tests focusing on search functionality and validation. + +### ViewsTestCase +- **test_search_view_get**: Tests GET request to search view returns 200 status +- **test_search_view_post_with_query**: Tests POST request with query returns results +- **test_search_view_post_empty_query**: Tests POST request with empty query shows validation error +- **test_search_view_post_no_query**: Tests POST request without query parameter shows validation error + +--- + +## referenzen App Tests + +The referenzen app contains 18 tests focusing on MPTT hierarchy functionality and model relationships. + +### Model Tests + +#### ReferenzModelTest +- **test_referenz_creation**: Tests Referenz creation with required fields +- **test_referenz_str**: Tests string representation returns the reference text +- **test_referenz_ordering**: Tests default ordering by `order` field +- **test_referenz_optional_fields**: Tests optional fields can be blank + +#### ReferenzerklaerungModelTest +- **test_referenzerklaerung_creation**: Tests Referenzerklaerung creation with reference and explanation +- **test_referenzerklaerung_str**: Tests string representation includes reference and explanation preview +- **test_referenzerklaerung_ordering**: Tests default ordering by `order` field +- **test_referenzerklaerung_optional_explanation**: Tests explanation field can be blank + +### Hierarchy Tests + +#### ReferenzHierarchyTest +- **test_hierarchy_relationships**: Tests parent-child relationships in MPTT tree +- **test_get_root**: Tests getting the root node of a hierarchy +- **test_get_children**: Tests getting direct children of a node +- **test_get_descendants**: Tests getting all descendants of a node +- **test_get_ancestors**: Tests getting all ancestors of a node +- **test_get_ancestors_include_self**: Tests getting ancestors including the node itself +- **test_is_leaf_node**: Tests leaf node detection +- **test_is_root_node**: Tests root node detection +- **test_tree_ordering**: Tests tree ordering with multiple levels +- **test_move_node**: Tests moving nodes within the tree structure + +--- + +## rollen App Tests + +The rollen app contains 18 tests covering role models and their relationships with document sections. + +### Model Tests + +#### RolleModelTest +- **test_rolle_creation**: Tests Rolle creation with name and optional description +- **test_rolle_str**: Tests string representation returns the role name +- **test_rolle_ordering**: Tests default ordering by `order` field +- **test_rolle_unique_name**: Tests that role names must be unique +- **test_rolle_optional_beschreibung**: Tests description field can be blank + +#### RollenBeschreibungModelTest +- **test_rollenbeschreibung_creation**: Tests RollenBeschreibung creation with role and section type +- **test_rollenbeschreibung_str**: Tests string representation includes role and section type +- **test_rollenbeschreibung_ordering**: Tests default ordering by `order` field +- **test_rollenbeschreibung_unique_combination**: Tests unique constraint on role and section type +- **test_rollenbeschreibung_optional_beschreibung**: Tests description field can be blank + +### Relationship Tests + +#### RelationshipTest +- **test_rolle_rollenbeschreibung_relationship**: Tests one-to-many relationship between Rolle and RollenBeschreibung +- **test_abschnitttyp_rollenbeschreibung_relationship**: Tests relationship between AbschnittTyp and RollenBeschreibung +- **test_cascade_delete**: Tests cascade delete behavior when role is deleted +- **test_protected_delete**: Tests protected delete behavior when section type is referenced +- **test_query_related_objects**: Tests querying related objects efficiently +- **test_string_representations**: Tests all string representations work correctly +- **test_ordering_consistency**: Tests ordering is consistent across queries + +--- + +## stichworte App Tests + +The stichworte app contains 18 tests covering keyword models and their ordering. + +### Model Tests + +#### StichwortModelTest +- **test_stichwort_creation**: Tests Stichwort creation with keyword text +- **test_stichwort_str**: Tests string representation returns the keyword text +- **test_stichwort_ordering**: Tests default ordering by `stichwort` field +- **test_stichwort_unique**: Tests that keywords must be unique +- **test_stichwort_case_insensitive**: Tests case-insensitive uniqueness + +#### StichworterklaerungModelTest +- **test_stichworterklaerung_creation**: Tests Stichworterklaerung creation with keyword and explanation +- **test_stichworterklaerung_str**: Tests string representation includes keyword and explanation preview +- **test_stichworterklaerung_ordering**: Tests default ordering by `order` field +- **test_stichworterklaerung_optional_erklaerung**: Tests explanation field can be blank +- **test_stichworterklaerung_unique_stichwort**: Tests unique constraint on keyword + +### Relationship Tests + +#### RelationshipTest +- **test_stichwort_stichworterklaerung_relationship**: Tests one-to-one relationship between Stichwort and Stichworterklaerung +- **test_cascade_delete**: Tests cascade delete behavior when keyword is deleted +- **test_protected_delete**: Tests protected delete behavior when explanation is referenced +- **test_query_related_objects**: Tests querying related objects efficiently +- **test_string_representations**: Tests all string representations work correctly +- **test_ordering_consistency**: Tests ordering is consistent across queries +- **test_reverse_relationship**: Tests reverse relationship from explanation to keyword + +--- + +## Test Statistics + +- **Total Tests**: 206 +- **abschnitte**: 32 tests +- **dokumente**: 116 tests (98 in tests.py + 9 in test_json.py + 9 JSON tests in main tests.py) +- **pages**: 4 tests +- **referenzen**: 18 tests +- **rollen**: 18 tests +- **stichworte**: 18 tests + +## Test Coverage Areas + +1. **Model Validation**: Field validation, constraints, and relationships +2. **Business Logic**: Status determination, conflict detection, hierarchy management +3. **View Functionality**: HTTP responses, template rendering, URL resolution +4. **Utility Functions**: Text processing, caching, formatting +5. **Management Commands**: CLI interface and output handling +6. **Integration**: Cross-app functionality and data flow + +## Running the Tests + +To run all tests: +```bash +python manage.py test +``` + +To run tests for a specific app: +```bash +python manage.py test app_name +``` + +To run with verbose output: +```bash +python manage.py test --verbosity=2 +``` + +All tests are currently passing and provide comprehensive coverage of the application's functionality. \ No newline at end of file diff --git a/VorgabenUI/settings.py b/VorgabenUI/settings.py index ab3add7..80cc333 100644 --- a/VorgabenUI/settings.py +++ b/VorgabenUI/settings.py @@ -51,7 +51,6 @@ INSTALLED_APPS = [ 'mptt', 'pages', 'nested_admin', - 'revproxy.apps.RevProxyConfig', ] MIDDLEWARE = [ diff --git a/VorgabenUI/urls.py b/VorgabenUI/urls.py index 4a4427e..d072398 100644 --- a/VorgabenUI/urls.py +++ b/VorgabenUI/urls.py @@ -18,7 +18,6 @@ from django.contrib import admin from django.urls import include, path, re_path from django.conf import settings from django.conf.urls.static import static -from diagramm_proxy.views import DiagrammProxyView import dokumente.views import pages.views import referenzen.views @@ -33,7 +32,6 @@ urlpatterns = [ path('stichworte/', include("stichworte.urls")), path('referenzen/', referenzen.views.tree, name="referenz_tree"), path('referenzen//', referenzen.views.detail, name="referenz_detail"), - re_path(r'^diagramm/(?P.*)$', DiagrammProxyView.as_view()), ] # Serve static files diff --git a/abschnitte/tests.py b/abschnitte/tests.py index 7ce503c..8d8d8b9 100644 --- a/abschnitte/tests.py +++ b/abschnitte/tests.py @@ -1,3 +1,820 @@ -from django.test import TestCase +from django.test import TestCase, TransactionTestCase +from django.core.management import call_command +from django.conf import settings +from django.core.files.storage import default_storage +from unittest.mock import patch, Mock, MagicMock +from io import StringIO +import os +import hashlib +import tempfile +import shutil -# Create your tests here. +from .models import AbschnittTyp, Textabschnitt +from .utils import render_textabschnitte, md_table_to_html +from diagramm_proxy.diagram_cache import ( + get_cached_diagram, compute_hash, get_cache_path, clear_cache +) + + +class AbschnittTypModelTest(TestCase): + """Test cases for AbschnittTyp model""" + + def setUp(self): + """Set up test data""" + self.abschnitttyp = AbschnittTyp.objects.create( + abschnitttyp="text" + ) + + def test_abschnitttyp_creation(self): + """Test that AbschnittTyp is created correctly""" + self.assertEqual(self.abschnitttyp.abschnitttyp, "text") + + def test_abschnitttyp_str(self): + """Test string representation of AbschnittTyp""" + self.assertEqual(str(self.abschnitttyp), "text") + + def test_abschnitttyp_verbose_name_plural(self): + """Test verbose name plural""" + self.assertEqual( + AbschnittTyp._meta.verbose_name_plural, + "Abschnitttypen" + ) + + def test_abschnitttyp_primary_key(self): + """Test that abschnitttyp field is the primary key""" + pk_field = AbschnittTyp._meta.pk + self.assertEqual(pk_field.name, 'abschnitttyp') + + def test_create_multiple_abschnitttypen(self): + """Test creating multiple AbschnittTyp objects""" + types = ['liste ungeordnet', 'liste geordnet', 'tabelle', 'diagramm', 'code'] + for typ in types: + AbschnittTyp.objects.create(abschnitttyp=typ) + + self.assertEqual(AbschnittTyp.objects.count(), 6) # Including setUp type + + +class TextabschnittModelTest(TestCase): + """Test cases for Textabschnitt abstract model using VorgabeLangtext""" + + def setUp(self): + """Set up test data""" + from dokumente.models import Dokumententyp, Dokument, Vorgabe, VorgabeLangtext, Thema + from datetime import date + + self.typ_text = AbschnittTyp.objects.create(abschnitttyp="text") + self.typ_code = AbschnittTyp.objects.create(abschnitttyp="code") + + # Create required dokumente objects + self.dokumententyp = Dokumententyp.objects.create( + name="Test Type", verantwortliche_ve="TEST" + ) + self.dokument = Dokument.objects.create( + nummer="TEST-001", + name="Test Doc", + dokumententyp=self.dokumententyp, + aktiv=True + ) + self.thema = Thema.objects.create(name="Test Thema") + self.vorgabe = Vorgabe.objects.create( + dokument=self.dokument, + nummer=1, + order=1, + thema=self.thema, + titel="Test Vorgabe", + gueltigkeit_von=date.today() + ) + + def test_textabschnitt_creation(self): + """Test that Textabschnitt can be instantiated via concrete model""" + from dokumente.models import VorgabeLangtext + + abschnitt = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="Test content", + order=1 + ) + self.assertEqual(abschnitt.abschnitttyp, self.typ_text) + self.assertEqual(abschnitt.inhalt, "Test content") + self.assertEqual(abschnitt.order, 1) + + def test_textabschnitt_default_order(self): + """Test that order defaults to 0""" + from dokumente.models import VorgabeLangtext + + abschnitt = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="Test" + ) + self.assertEqual(abschnitt.order, 0) + + def test_textabschnitt_blank_fields(self): + """Test that abschnitttyp and inhalt can be blank/null""" + from dokumente.models import VorgabeLangtext + + abschnitt = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe + ) + self.assertIsNone(abschnitt.abschnitttyp) + self.assertIsNone(abschnitt.inhalt) + + def test_textabschnitt_ordering(self): + """Test that Textabschnitte can be ordered""" + from dokumente.models import VorgabeLangtext + + abschnitt1 = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="First", + order=2 + ) + abschnitt2 = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="Second", + order=1 + ) + abschnitt3 = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="Third", + order=3 + ) + + ordered = VorgabeLangtext.objects.filter(abschnitt=self.vorgabe).order_by('order') + self.assertEqual(list(ordered), [abschnitt2, abschnitt1, abschnitt3]) + + def test_textabschnitt_foreign_key_protection(self): + """Test that AbschnittTyp is protected from deletion""" + from dokumente.models import VorgabeLangtext + from django.db.models import ProtectedError + + abschnitt = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="Test" + ) + + # Try to delete the AbschnittTyp + with self.assertRaises(ProtectedError): + self.typ_text.delete() + + +class RenderTextabschnitteTest(TestCase): + """Test cases for render_textabschnitte function""" + + def setUp(self): + """Set up test data""" + from dokumente.models import Dokumententyp, Dokument, Vorgabe, VorgabeLangtext, Thema + from datetime import date + + self.typ_text = AbschnittTyp.objects.create(abschnitttyp="text") + self.typ_unordered = AbschnittTyp.objects.create(abschnitttyp="liste ungeordnet") + self.typ_ordered = AbschnittTyp.objects.create(abschnitttyp="liste geordnet") + self.typ_table = AbschnittTyp.objects.create(abschnitttyp="tabelle") + self.typ_code = AbschnittTyp.objects.create(abschnitttyp="code") + self.typ_diagram = AbschnittTyp.objects.create(abschnitttyp="diagramm") + + # Create required dokumente objects + self.dokumententyp = Dokumententyp.objects.create( + name="Test Type", verantwortliche_ve="TEST" + ) + self.dokument = Dokument.objects.create( + nummer="TEST-001", + name="Test Doc", + dokumententyp=self.dokumententyp, + aktiv=True + ) + self.thema = Thema.objects.create(name="Test Thema") + self.vorgabe = Vorgabe.objects.create( + dokument=self.dokument, + nummer=1, + order=1, + thema=self.thema, + titel="Test Vorgabe", + gueltigkeit_von=date.today() + ) + + def test_render_empty_queryset(self): + """Test rendering an empty queryset""" + from dokumente.models import VorgabeLangtext + + result = render_textabschnitte(VorgabeLangtext.objects.none()) + self.assertEqual(result, []) + + def test_render_text_markdown(self): + """Test rendering plain text with markdown""" + from dokumente.models import VorgabeLangtext + + abschnitt = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="# Heading\n\nThis is **bold** text.", + order=1 + ) + + result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe)) + self.assertEqual(len(result), 1) + typ, html = result[0] + self.assertEqual(typ, "text") + self.assertIn("

Heading

", html) + self.assertIn("bold", html) + + def test_render_text_with_footnotes(self): + """Test rendering text with footnotes""" + from dokumente.models import VorgabeLangtext + + abschnitt = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_text, + inhalt="This is text[^1].\n\n[^1]: This is a footnote.", + order=1 + ) + + result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe)) + typ, html = result[0] + self.assertIn("footnote", html.lower()) + + def test_render_unordered_list(self): + """Test rendering unordered list""" + from dokumente.models import VorgabeLangtext + + abschnitt = VorgabeLangtext.objects.create( + abschnitt=self.vorgabe, + abschnitttyp=self.typ_unordered, + inhalt="Item 1\nItem 2\nItem 3", + order=1 + ) + + result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe)) + typ, html = result[0] + self.assertEqual(typ, "liste ungeordnet") + self.assertIn("