De quoi dépend la gradation du niveau de gravité des…

La gradation du niveau de gravité des erreurs (severity) dépend de l’impact du défaut sur la fonctionnalité, la stabilité ou la sécurité du produit logiciel. On évalue le dommage potentiel pour l’utilisateur ou l’entreprise.

Les facteurs principaux influençant la gravité :

Criticité de la fonctionnalité : À quel point la fonction affectée est importante pour le fonctionnement de l’application.
Impact sur les opérations principales : Si le défaut empêche l’accomplissement de tâches clés.
Perte de données ou de fonds : Si le défaut peut entraîner une fuite ou une perte de données, ainsi que des pertes financières.
Disponibilité du système : Si le défaut bloque totalement ou partiellement l’utilisation de l’application.
Possibilité de solution alternative : S’il existe une autre façon d’effectuer l’action.
Fréquence d’apparition : À quelle fréquence le défaut se manifeste (bien que cela soit plus un facteur de priorité, cela peut aussi influencer la gravité si le défaut est critique et constant).

Les niveaux typiques de gravité (qui peuvent varier selon le projet et l’entreprise) :

Bloqueur : Le produit est totalement inutilisable, la fonctionnalité critique est bloquée, il est impossible de continuer le travail ou les tests. Perte de données ou pertes financières garanties.
Critique : La fonctionnalité critique ne fonctionne pas ou fonctionne de manière incorrecte. Les opérations principales sont gravement affectées, mais une opération partielle est possible. Pas de solution de contournement.
Majeur : La fonctionnalité importante mais non critique ne fonctionne pas ou fonctionne incorrectement. Il peut y avoir des perturbations dans les opérations principales, mais une solution de contournement existe. Des pertes de données peuvent survenir, mais pas critiques.
Mineur : Perturbations mineures de la fonctionnalité ou problèmes d’utilisabilité. N’affecte pas les opérations principales. Une solution simple est disponible.
Trivial : Défauts cosmétiques, erreurs dans le texte, n’affectant pas la fonctionnalité.

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

func determineSeverity(defectFunctionality: FunctionalityLevel, impact: ImpactLevel) -> DefectSeverity {
    switch (defectFunctionality, impact) {
    case (.critical, .blocksAll): return .blocker // Fonction critique, bloque complètement le travail
    case (.critical, .majorIssue): return .critical // Fonction critique, problèmes graves
    case (.essential, .blocksAll): return .critical // Fonction principale, bloque complètement le travail
    case (.essential, .majorIssue): return .major // Fonction principale, problèmes graves
    case (_, .minorIssue): return .minor // Problèmes mineurs
    case (_, .cosmetic): return .trivial // Problèmes cosmétiques
    default: return .minor // Valeur par défaut
    }
}

enum FunctionalityLevel {
    case critical, essential, minor
}

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

// Utilisation :
let severity = determineSeverity(defectFunctionality: .critical, impact: .blocksAll)
print(severity) // Affichera : blocker

De quoi dépend la gradation du niveau de gravité des erreurs (sévérité) ?