Niveaux de test logiciel

Les tests logiciels comportent plusieurs niveaux. Ils se divisent aussi en deux grandes catégories, les tests fonctionnels et les tests non fonctionnels. Le chapitre suivant présente ces catégories en détail.

Vue d’ensemble des niveaux de test logiciel

Il existe quatre niveaux de test.

• Tests unitaires
• Tests d’intégration
• Tests système
• Tests d’acceptation

Ouvrir le schéma en taille réelle ↗

Vue d’ensemble des niveaux de test logiciel

Tests unitaires

Une unité est la plus petite partie autonome et testable du code source. Les tests unitaires constituent le premier niveau. Ils sont généralement réalisés par les développeurs ou par des membres de leur équipe. Terminez-les avant d’intégrer les unités. Un plan de test unitaire et des cas de test bien définis sont essentiels.

Les tests unitaires permettent de passer à l’intégration avec la certitude que chaque unité fonctionne correctement. Tester en parallèle du développement peut sembler ralentir le travail au début, puisque les défauts découverts nécessitent des modifications du code. Avec le temps, le code s’améliore et le nombre de défauts diminue. Cela crée une base plus solide, accélère la suite du développement et fait gagner du temps.

Ouvrir le schéma en taille réelle ↗

Tests unitaires

Des tests unitaires efficaces font également économiser de l’argent. La correction des défauts coûte généralement bien plus cher en fin de développement qu’au début.

Les tests unitaires couvrent de petits composants. Leurs cas et leurs données ne permettent donc pas de vérifier tous les scénarios fonctionnels et tous les flux d’information d’une application. Certains scénarios ne peuvent être testés qu’après avoir assemblé plusieurs unités en un composant plus large.

Tests d’intégration

Après les tests unitaires, les tests d’intégration vérifient comment deux unités ou plus interagissent et quels résultats elles produisent selon les scénarios. Ces tests sont réalisés par des ingénieurs en test logiciel.

Les tests d’intégration révèlent les défauts liés aux fonctions, aux exigences et aux performances. Les tests unitaires vérifient que les composants fonctionnent individuellement. Les tests d’intégration vérifient qu’ils fonctionnent ensemble comme prévu. Voici les principales approches.

1. Intégration globale (big bang)
2. Intégration descendante
3. Intégration ascendante

Lors d’un test d’intégration globale, tous les modules sont assemblés dans le système complet. On vérifie ensuite si le système présente des défauts.

Ouvrir le schéma en taille réelle ↗

Tests d’intégration

L’intégration descendante commence par les modules de plus haut niveau, puis ajoute et teste un à un les modules inférieurs. L’intégration ascendante suit l’ordre inverse. Testez d’abord les modules de niveau le plus bas, puis ajoutez progressivement ceux des niveaux supérieurs. Une séquence courante consiste à commencer par des tests ascendants, puis à effectuer des tests descendants.

Ouvrir le schéma en taille réelle ↗

Tests d’intégration descendante et ascendante

Dans les tests descendants, les bouchons de test, ou stubs, remplacent les modules ou sous-programmes inférieurs indisponibles ou inachevés. Dans les tests ascendants, un pilote, ou driver, joue le rôle du programme appelant lorsque le programme de niveau supérieur n’est pas encore disponible.

Tests système

Après une intégration réussie, les tests système examinent le fonctionnement de l’ensemble du système et de ses composants réunis. Ils vérifient les performances, les spécifications fonctionnelles et techniques, ainsi que les normes de qualité de l’organisation. Une équipe de test hautement qualifiée doit effectuer ce travail dans un environnement qui se rapproche autant que possible des conditions réelles de déploiement.

Ouvrir le schéma en taille réelle ↗

Tests système

Les tests système se font exclusivement en boîte noire. Ils vérifient le système au regard des exigences et du point de vue des utilisateurs, notamment le comportement de l’application, sa conception et les attentes des utilisateurs finaux. Ils permettent de vérifier et de valider l’architecture de l’application ainsi que les exigences métier du client.

Tests d’acceptation

Après les tests unitaires, d’intégration et système, les tests d’acceptation examinent la qualité et l’exactitude à l’aide de scénarios et de cas prédéfinis. L’équipe d’assurance qualité examine le système sous plusieurs angles, dont son apparence et son fonctionnement interne. Cette étape est essentielle, car l’acceptation du client dépend également des exigences légales et contractuelles. Elle comprend les tests suivants.

1. Tests d’acceptation utilisateur. Des utilisateurs réels testent le logiciel avant de l’accepter, soit sur leur propre site, soit chez l’organisation qui l’a développé.
2. Tests d’acceptation opérationnelle. Vérifiez que les processus et procédures nécessaires pour utiliser et maintenir le système sont en place.
3. Tests d’acceptation contractuelle et réglementaire. Vérifiez le respect des exigences contractuelles et des règles gouvernementales, juridiques et de sécurité applicables.
4. Tests alpha. Évaluez la qualité globale du produit et préparez les tests bêta vers la fin du développement, lorsque le système complet peut être testé. Les ingénieurs de test et les autres membres de l’équipe examinent la qualité et la réalisation technique du point de vue du client. Ce travail peut prendre beaucoup de temps.
5. Tests bêta. Après les tests alpha, des utilisateurs réels essaient le produit dans des conditions réelles afin d’améliorer sa qualité et de vérifier qu’il répond à leurs besoins. Les tests bêta ont lieu quelques jours ou semaines avant le lancement et peuvent durer plusieurs jours. Ils peuvent être plus courts que les tests alpha, car la probabilité de découvrir des défauts est relativement faible à ce stade.

Ouvrir le schéma en taille réelle ↗

Tests d’acceptation