Wovon hängt die Einstufung des Schweregrads von…

Die Einstufung des Schweregrads (severity) von Fehlern hängt von der Auswirkung des Defekts auf Funktionalität, Stabilität oder Sicherheit des Softwareprodukts ab. Es wird der potenzielle Schaden für den Nutzer oder das Unternehmen bewertet.

Hauptfaktoren, die die Schwere beeinflussen:

Kritikalität der Funktion: Wie wichtig ist die betroffene Funktion für den Betrieb der Anwendung.
Auswirkungen auf Hauptoperationen: Beeinträchtigt der Defekt die Ausführung wichtiger Aufgaben.
Daten- oder Geldverlust: Kann der Defekt zu Daten- oder Geldverlusten führen.
Systemverfügbarkeit: Blockiert der Defekt die Nutzung der Anwendung vollständig oder teilweise.
Umgehungsmöglichkeiten: Gibt es eine alternative Möglichkeit, die Aktion auszuführen.
Häufigkeit des Auftretens: Wie oft tritt der Defekt auf (obwohl dies eher ein Prioritätsfaktor ist, kann es auch die Schwere beeinflussen, wenn der Defekt kritisch und konstant ist).

Typische Schweregrade (können je nach Projekt und Unternehmen variieren):

Blocker: Das Produkt ist vollständig unbrauchbar, kritische Funktionalität ist blockiert, Weiterarbeit oder Tests sind unmöglich. Daten- oder finanzielle Verluste sind garantiert.
Kritisch: Kritisch wichtige Funktion funktioniert nicht oder fehlerhaft. Hauptoperationen sind schwer beeinträchtigt, aber eine teilweise Arbeit ist möglich. Es gibt keinen Umgehungsweg.
Haupt: Wichtige, aber nicht kritische Funktion funktioniert nicht oder fehlerhaft. Es kann zu Störungen in den Hauptoperationen kommen, aber es gibt eine Umgehung. Datenverluste sind möglich, aber nicht kritisch.
Neben: Geringfügige Störung der Funktionalität oder Usability-Probleme. Beeinträchtigt die Hauptoperationen nicht. Es gibt eine einfache Umgehung.
Trivial: Kosmetische Fehler, Textfehler, die die Funktionalität nicht beeinträchtigen.

enum DefectSeverity {
    case blocker, critical, major, minor, trivial
}

func determineSeverity(defectFunctionality: FunctionalityLevel, impact: ImpactLevel) -> DefectSeverity {
    switch (defectFunctionality, impact) {
    case (.critical, .blocksAll): return .blocker // Kritische Funktion, blockiert die Arbeit vollständig
    case (.critical, .majorIssue): return .critical // Kritische Funktion, schwerwiegende Probleme
    case (.essential, .blocksAll): return .critical // Hauptfunktion, blockiert die Arbeit vollständig
    case (.essential, .majorIssue): return .major // Hauptfunktion, schwerwiegende Probleme
    case (_, .minorIssue): return .minor // Geringfügige Probleme
    case (_, .cosmetic): return .trivial // Kosmetische Probleme
    default: return .minor // Standardwert
    }
}

enum FunctionalityLevel {
    case critical, essential, minor
}

enum ImpactLevel {
    case blocksAll, majorIssue, minorIssue, cosmetic
}

// Verwendung:
let severity = determineSeverity(defectFunctionality: .critical, impact: .blocksAll)
print(severity) // Gibt aus: blocker

Wovon hängt die Einstufung des Schweregrads von Fehlern (Schwere) ab?