Les tests non fonctionnels font référence aux tests de logiciels effectués pour tester les aspects non fonctionnels d’une application logicielle.
Il existe de nombreux types de tests non fonctionnels, et certains types de tests de logiciels peuvent être considérés à la fois comme des tests fonctionnels et non fonctionnels.
Les tests non fonctionnels sont nécessaires parce qu’ils évaluent des critères essentiels pour l’utilisateur, tels que la performance et la facilité d’utilisation, et vérifient si le logiciel fonctionne comme prévu en dehors de ses fonctionnalités de base.
Dans cet article, nous explorons la définition et les caractéristiques des tests non fonctionnels, ainsi que les types de tests non fonctionnels, les approches des tests non fonctionnels et les outils de test qui peuvent vous aider à optimiser et à améliorer vos propres processus de tests non fonctionnels.
Qu’est-ce qu’un test non fonctionnel ?
Les tests non fonctionnels sont tous les types de tests de logiciels où les aspects non fonctionnels de la construction du logiciel sont testés.
Parmi les exemples de tests non fonctionnels, on peut citer les tests destinés à évaluer la capacité, les performances, la facilité d’utilisation, la récupération et la portabilité.
La vérification de la qualité et de l’état de chacun de ces critères non fonctionnels est tout aussi importante que la vérification des fonctions d’un logiciel, mais ces paramètres ne sont pas testés dans le cadre des tests fonctionnels standard.
Essentiellement, les tests non fonctionnels consistent à tester « comment » les fonctions du logiciel fonctionnent plutôt que de tester « si » elles fonctionnent.
1. Quand avez-vous besoin de tests non fonctionnels ?
Les tests non fonctionnels sont effectués au cours de la phase de test du système, après les tests unitaires et les tests d’intégration.
Au cours des essais du système, les testeurs effectuent des essais fonctionnels et non fonctionnels, en commençant par les essais fonctionnels.
Une fois que les testeurs ont établi que le logiciel fonctionne comme prévu, ils effectuent des tests non fonctionnels pour déterminer s’il répond également aux paramètres non fonctionnels.
Il est généralement nécessaire d’effectuer les tests fonctionnels avant les tests non fonctionnels, car il est impossible de tester la fiabilité ou les performances de fonctions qui ne fonctionnent pas du tout. Les tests non fonctionnels sont l’une des dernières étapes des tests de logiciels avant les tests d’acceptation par l’utilisateur et la sortie du produit final.
2. Quand les tests non fonctionnels ne sont pas nécessaires
Il est toujours important de tester les aspects non fonctionnels d’un logiciel, sauf s’ils ont déjà été testés et jugés adéquats.
Même si vous avez déjà effectué des tests non fonctionnels sur un logiciel, il peut être nécessaire de tester à nouveau des paramètres non fonctionnels, par exemple si de nouvelles fonctionnalités ont été ajoutées au logiciel ou si des changements ont été apportés au code qui pourraient affecter les performances et la fiabilité.
Les objectifs des tests non fonctionnels
Les objectifs des tests non fonctionnels sont de vérifier que le produit répond aux attentes des utilisateurs et d’optimiser le produit avant sa sortie.
Elle peut également aider les développeurs et les testeurs à mieux comprendre le logiciel et à utiliser ces connaissances pour de futures optimisations.
1. Contrôle de la qualité
Les essais non fonctionnels visent à tester les facteurs qui ont un impact sur la facilité d’utilisation, la fiabilité, la maintenabilité, la portabilité et l’efficacité du produit.
En testant ces éléments, on s’assure que le produit mis sur le marché est d’une qualité suffisante et qu’il répond aux attentes des utilisateurs en termes de performances, de temps de chargement et de capacité d’utilisation.
2. La gestion des risques
Les tests non fonctionnels réduisent également les risques et les coûts associés à la mise sur le marché d’un produit en maximisant les chances de l’équipe de mettre sur le marché un produit satisfaisant.
En vérifiant les paramètres non fonctionnels de la conception du logiciel, il est possible de réduire les coûts de mise sur le marché du produit, car la nécessité de poursuivre le développement et de modifier le logiciel ultérieurement est réduite.
3. L’optimisation
Les tests non fonctionnels aident les testeurs et les développeurs à optimiser la conception du logiciel et à optimiser les performances lors de l’installation, de la configuration, de l’exécution et de l’utilisation.
Vous pouvez également utiliser les tests non fonctionnels pour optimiser la façon dont vous gérez et surveillez la construction du logiciel.
4. Collecte des données
Les tests non fonctionnels permettent aux testeurs de collecter et de produire des mesures et des paramètres qui peuvent être utilisés par les équipes de test pour la recherche et le développement internes.
Vous pouvez utiliser les données recueillies lors des tests non fonctionnels pour comprendre comment fonctionne votre produit et comment vous pouvez l’optimiser plus efficacement pour les utilisateurs.
5. Amélioration des connaissances
Les tests non fonctionnels améliorent et renforcent les connaissances de l’équipe de test sur le comportement du produit et les technologies qu’il utilise.
Non seulement cela aide les équipes de test à mieux comprendre le logiciel sur lequel elles travaillent, mais cela peut également fournir des connaissances utiles qui aident les testeurs à mieux comprendre les futures versions.
Qui est impliqué dans les tests non fonctionnels ?
Les tests non fonctionnels sont généralement effectués par des testeurs dans l’environnement d’assurance qualité, mais il arrive que les développeurs effectuent des tests non fonctionnels au cours du développement.
Les tests de système sont presque toujours effectués par des testeurs, et c’est la phase de test où la plupart des tests non fonctionnels ont lieu.
Si les tests non fonctionnels échouent, les testeurs renvoient le logiciel aux développeurs pour qu’ils corrigent les erreurs de performance avant de procéder à un nouveau test.
Les avantages des tests non fonctionnels
Les tests non fonctionnels présentent de nombreux avantages et constituent une étape essentielle des tests de systèmes.
Sans les tests non fonctionnels, les équipes de test ne seraient pas en mesure de vérifier que le logiciel répond réellement aux exigences du client ou qu’il répond aux exigences définies dans le plan de développement du logiciel.
1. Améliorer les performances des logiciels
Les tests non fonctionnels peuvent aider les testeurs et les développeurs à améliorer les performances globales des applications logicielles. Les tests non fonctionnels identifient les domaines dans lesquels les performances du logiciel sont insuffisantes, par exemple en termes de vitesse de chargement ou de capacité de traitement, et incitent les équipes logicielles à apporter des modifications pour corriger ces défauts.
Cela garantit que les équipes logicielles ne diffusent le logiciel au public que lorsqu’il est prêt et que ses performances sont suffisantes.
2. Assurer la sécurité des logiciels
Les tests non fonctionnels comprennent les tests de sécurité, qui sont essentiels pour garantir qu’un logiciel est sécurisé et protégé contre les menaces et les attaques extérieures.
Les tests de sécurité permettent aux testeurs et aux développeurs de vérifier que les logiciels protègent correctement les données confidentielles et qu’ils disposent d’une sécurité suffisante pour se prémunir contre les cyberattaques contemporaines.
3. Améliorer la convivialité du logiciel
Les tests non fonctionnels sont le meilleur moyen de rendre votre logiciel plus convivial, notamment en effectuant des tests d’utilisabilité qui évaluent la facilité avec laquelle les utilisateurs apprennent à se servir de votre logiciel et à le faire fonctionner.
La convivialité est très importante car elle détermine le degré de satisfaction des utilisateurs à l’égard de votre logiciel et garantit que les utilisateurs sont capables de tirer pleinement parti de tout ce que votre logiciel offre.
4. S’assurer que le logiciel répond aux besoins des utilisateurs
S’assurer que les logiciels répondent aux besoins des utilisateurs devrait être l’une des principales priorités de toutes les équipes de développement et de test de logiciels. Les utilisateurs s’attendent non seulement à ce que le logiciel soit fonctionnel, mais aussi à ce qu’il soit performant, qu’il fonctionne sans heurts et qu’il protège les données confidentielles.
Les tests non fonctionnels sont l’un des seuls moyens de s’assurer que votre logiciel répond à ces exigences.
Les défis des tests non fonctionnels
Les tests non fonctionnels présentent certains inconvénients. Bien que les tests non fonctionnels soient essentiels pendant la phase de test du système, le processus de test non fonctionnel peut poser des problèmes aux équipes logicielles qui ne disposent pas de ressources et d’outils suffisants.
1. La répétition
Les tests non fonctionnels doivent être effectués à chaque fois que le logiciel est mis à jour par les développeurs ou à chaque fois que le code est modifié. Cela signifie que les tests non fonctionnels peuvent être très répétitifs, ce qui prend du temps et fatigue les testeurs.
Les testeurs fatigués qui effectuent des tâches très répétitives sont également plus susceptibles d’être distraits et de commettre des erreurs.
2. Coût
Les tests non fonctionnels étant très répétitifs, ils peuvent également être très coûteux, en particulier pour les équipes de test qui s’appuient sur des tests non fonctionnels manuels.
Les équipes logicielles doivent consacrer du temps et du budget à des tests non fonctionnels fréquents, et les développeurs de logiciels devront payer un supplément pour ces tests supplémentaires.
Que testons-nous dans le cadre des tests non fonctionnels ?
Les tests non fonctionnels peuvent être utilisés pour tester de nombreux paramètres non fonctionnels différents, chacun d’entre eux affectant la qualité et la facilité d’utilisation du système. Chacun de ces paramètres est testé pendant les essais du système en fonction de critères définis dans le plan d’essai.
1. La sécurité
Les tests de sécurité sont un type de tests non fonctionnels qui mesurent le degré de protection d’un système contre les menaces et les attaques extérieures. Il s’agit notamment de violations délibérées de la sécurité, de fuites de données et d’autres violations courantes.
Les tests de sécurité constituent une étape importante des tests non fonctionnels, car ils donnent aux utilisateurs finaux et aux clients l’assurance que leurs données sont sécurisées.
2. Fiabilité
Les testeurs utilisent les tests non fonctionnels pour évaluer la fiabilité d’un logiciel et s’assurer que le logiciel peut continuellement exécuter ses fonctions spécifiées sans défaillance.
Alors que les tests fonctionnels garantissent que le logiciel exécute ses fonctions clés, seuls les tests non fonctionnels testent réellement la fiabilité et la reproductibilité de ces résultats.
3. Capacité de survie
La survivabilité décrit la manière dont un système logiciel réagit en cas de défaillance, et les tests de survivabilité garantissent qu’en cas d’erreurs et de défaillances, le système peut se rétablir.
Les tests de survie permettent de vérifier si le logiciel est capable de sauvegarder les données afin de minimiser la perte de données en cas de défaillance soudaine, par exemple.
4. La disponibilité
La disponibilité du logiciel correspond à la mesure dans laquelle l’utilisateur peut compter sur le système pendant son fonctionnement. C’est ce que l’on appelle la stabilité, qui est testée par des essais de stabilité.
Les tests de stabilité ressemblent quelque peu aux tests de fiabilité, car ils permettent de vérifier si le système peut fonctionner de manière cohérente selon les normes attendues.
5. Facilité d’utilisation
Les tests d’utilisabilité sont un autre type important de tests non fonctionnels dans les tests de logiciels. Ce type de test évalue dans quelle mesure l’utilisateur peut apprendre, faire fonctionner et utiliser le système logiciel en suivant les instructions fournies à l’écran et d’autres guides de base.
Les tests d’utilisabilité sont importants car si le logiciel n’est pas très utilisable, la plupart des utilisateurs l’abandonneront tout simplement ou choisiront d’utiliser quelque chose d’autre.
6. L’évolutivité
Les tests d’évolutivité permettent de vérifier dans quelle mesure une application logicielle peut étendre sa capacité de traitement pour répondre à une demande croissante.
Par exemple, si le logiciel est conçu pour être utilisé simultanément par plusieurs utilisateurs sur un même réseau, comment fonctionne-t-il lorsque dix utilisateurs se connectent en même temps ? Un nombre élevé d’utilisateurs affecte-t-il de manière significative les performances ou les temps de chargement ?
7. L’interopérabilité
Le test d’interopérabilité est un type de test non fonctionnel qui vérifie la qualité de l’interface d’un système logiciel avec d’autres systèmes logiciels.
Ceci est particulièrement important lorsque le logiciel est conçu comme faisant partie d’une suite de produits qui s’intègrent les uns aux autres.
8. L’efficacité
L’efficacité dans les tests de logiciels se réfère à la mesure dans laquelle un système logiciel peut gérer la capacité, la quantité et le temps de réponse.
Par exemple, les testeurs peuvent évaluer le nombre d’utilisateurs qui peuvent se connecter au système en même temps, le temps nécessaire pour extraire des données de la base de données ou la rapidité avec laquelle le logiciel peut effectuer des tâches de base.
9. La flexibilité
La flexibilité mesure la mesure dans laquelle un système logiciel peut fonctionner avec différents types de matériel et de périphériques.
Par exemple, la quantité de mémoire vive dont le logiciel a besoin ou s’il nécessite une certaine quantité d’unité centrale. Plus les exigences de l’application logicielle sont faibles, plus le logiciel est flexible.
10. La portabilité
Le test de portabilité est utilisé pour tester la flexibilité avec laquelle le logiciel peut être transféré de son environnement matériel ou logiciel actuel, et la facilité avec laquelle cela peut se faire.
La portabilité est importante car elle affecte la facilité avec laquelle les utilisateurs finaux peuvent gérer les logiciels et les déplacer entre différents systèmes.
11. Réutilisation
Le test de réutilisation est un type de test non fonctionnel qui vérifie si des parties du système logiciel peuvent être converties pour être réutilisées dans une autre application.
Bien que les tests de réutilisation n’affectent généralement pas les clients et les utilisateurs finaux, ils reflètent bien l’efficacité avec laquelle les développeurs créent des composants qui pourront être réutilisés à l’avenir.
Les caractéristiques des tests non fonctionnels
Comprendre ce que sont les tests non fonctionnels implique de comprendre les caractéristiques des tests non fonctionnels. Ces caractéristiques définissent les tests non fonctionnels dans les tests de logiciels.
1. Mesurable
Les tests non fonctionnels sont toujours quantitatifs et mesurables, ce qui signifie que les testeurs n’utilisent pas d’expressions subjectives telles que « beau » ou « bon », mais plutôt des chiffres et des faits pour décrire les résultats des tests non fonctionnels.
Par exemple, plutôt que de décrire les temps de chargement comme « rapides » ou « lents », les tests non fonctionnels doivent aboutir à des chiffres précis indiquant le nombre de fois.
2. Spécifique
Lors de la réalisation de tests non fonctionnels, l’objectif des tests doit être spécifique aux spécifications de conception du logiciel.
Par exemple, si le plan du projet de logiciel fait référence au nombre d’utilisateurs qui doivent pouvoir se connecter en même temps, il convient d’en faire une priorité lors des tests non fonctionnels.
3. Inconnu
Si les tests non fonctionnels peuvent être spécifiquement conçus pour mesurer les attributs définis dans les plans de projet, dans de nombreux cas, ces attributs ne seront pas spécifiés à l’avance.
Dans ce cas, les testeurs devraient simplement effectuer des tests non fonctionnels pour évaluer le logiciel en fonction de chaque paramètre et comparer ensuite ces résultats aux attentes.
Le cycle de vie des tests non fonctionnels
Étant donné que les tests non fonctionnels ne se réfèrent pas à une phase spécifique du cycle de vie des tests de logiciels, mais simplement à un type de test qui a généralement lieu pendant la phase de test du système, le cycle de vie des tests non fonctionnels peut varier considérablement d’un projet à l’autre.
En général, il suit un cycle de vie similaire à celui des autres types de tests de logiciels, qui commence par l’analyse des exigences du projet et se termine par l’exécution des tests et la réalisation du cycle.
1. Analyse des besoins en logiciels
La première étape du cycle de vie des tests non fonctionnels est l’analyse des exigences du logiciel. Les équipes logicielles travaillent en fonction de critères spécifiques lorsqu’elles construisent et testent des applications, et ces critères devraient dicter le type de tests à effectuer.
2. Planification des tests
L’étape suivante du cycle de vie est la planification des tests. Au cours de la phase de planification des tests, le responsable AQ élabore un plan de test détaillé qui précise ce qui sera testé, qui effectuera les tests et quelles approches, méthodes et outils de test seront utilisés.
Le plan de test doit inclure tous les détails nécessaires aux testeurs pour créer et exécuter les cas de test.
3. Création de cas de test
La création de cas de test est l’étape suivante des tests non fonctionnels. Cette étape consiste à développer des cas de tests non fonctionnels que les testeurs exécuteront ultérieurement pour tester les exigences non fonctionnelles du système.
Les cas de test décrivent ce qui sera testé, comment cela sera testé et quel est le résultat attendu du test.
4. Configuration de l’environnement de test
L’étape suivante du cycle de vie des tests non fonctionnels consiste à mettre en place l’environnement de test avant le début des tests.
L’environnement de test est l’endroit où tous les tests ont lieu, et il abrite les ressources et les outils que vous utiliserez pour exécuter les tests non fonctionnels.
L’équipe de test prépare l’environnement de test avant l’exécution du test.
5. Exécution des tests
L’exécution des tests est la phase suivante du cycle de vie des tests non fonctionnels. Il s’agit d’exécuter les cas de test créés précédemment pour tester différents aspects des applications logicielles, notamment la sécurité, les temps de chargement, la capacité et la portabilité.
L’équipe de test exécute chaque cas individuellement et vérifie le résultat de chaque test par rapport au résultat attendu.
6. Répétition du cycle
La dernière étape du cycle de vie des tests non fonctionnels est l’accomplissement du cycle et la répétition. Après avoir exécuté tous les cas de test, les testeurs vérifient quels sont les tests qui ont réussi et ceux qui ont échoué.
Les tests qui échouent indiquent généralement qu’il y a un défaut qui doit être corrigé par les développeurs. Une fois que les développeurs ont corrigé ou modifié le code, le cycle de test du logiciel se répète jusqu’à ce qu’aucun défaut ne soit détecté.
Pour dissiper une certaine confusion :
Tests non fonctionnels et tests fonctionnels
Les tests fonctionnels et les tests non fonctionnels sont deux types de tests de logiciels différents mais tout aussi importants qui, ensemble, sont utilisés pour évaluer si une application logicielle répond aux exigences des utilisateurs telles qu’elles sont définies dans le cahier des charges du projet.
Bien qu’il s’agisse de deux types de tests nécessaires pour permettre aux équipes logicielles d’identifier les défauts dans les logiciels, les tests fonctionnels et non fonctionnels sont totalement distincts les uns des autres.
1. Quelle est la différence entre les tests fonctionnels et non fonctionnels ?
La différence entre les tests fonctionnels et non fonctionnels réside dans ce qu’ils testent. Les tests fonctionnels testent les fonctions de l’application et vérifient qu’elles fonctionnent comme prévu. Les tests non fonctionnels testent d’autres aspects de l’application qui affectent la satisfaction de l’utilisateur et la qualité de l’application.
Les tests fonctionnels et non fonctionnels interviennent dans différentes phases des tests de logiciels, mais les deux types de tests sont généralement effectués au cours de la phase de test du système.
Les tests fonctionnels et non fonctionnels peuvent nous aider à comprendre le fonctionnement d’une application et à déterminer si elle remplit sa mission de manière adéquate.
Par exemple, si vous testez une application mobile qui permet aux utilisateurs d’enregistrer des listes de tâches et de courses, les tests fonctionnels peuvent porter sur des fonctions telles que la création d’une nouvelle liste, l’enregistrement d’une liste et la modification de listes existantes.
Les tests non fonctionnels permettent d’évaluer le fonctionnement de l’application sur différents appareils mobiles, la rapidité de chargement des listes et l’impact sur les performances de l’application de l’exécution d’autres applications en arrière-plan.
2. Conclusion : tests non fonctionnels et tests fonctionnels
Les tests fonctionnels et non fonctionnels sont des types importants de tests de logiciels qui peuvent aider les testeurs et les équipes d’assurance qualité à évaluer si une application répond à ses exigences actuelles.
Alors que les essais fonctionnels testent les fonctions du logiciel, les essais non fonctionnels testent d’autres aspects susceptibles d’affecter les performances, l’efficacité et la sécurité.
Les tests unitaires, les tests d’intégration et les tests d’API sont tous des formes de tests fonctionnels. À chacune de ces étapes du test de logiciels, les testeurs évaluent la qualité du fonctionnement des fonctions et des caractéristiques, individuellement ou ensemble, et identifient les bogues et les défauts qui empêchent les fonctions de fonctionner comme prévu.
Les tests de sécurité, les tests de convivialité, les tests de portabilité et les tests de charge sont autant de formes de tests non fonctionnels qui permettent aux testeurs d’évaluer dans quelle mesure une application remplit ses fonctions et répond aux besoins des utilisateurs.
Types de tests non fonctionnels
Il existe de nombreux types de tests non fonctionnels, chacun d’entre eux testant un aspect non fonctionnel différent de la performance ou de l’efficacité d’une application logicielle.
Chacun de ces types de tests teste des paramètres différents, et certains tests peuvent tester les mêmes paramètres de différentes manières.
1. Tests de performance
Les tests de performance sont un type de test non fonctionnel qui vérifie le fonctionnement de différents composants logiciels. Plutôt que de tester leur fonctionnalité, ce que font les tests fonctionnels, les tests de performance peuvent tester les temps de réponse, les goulets d’étranglement et les points de défaillance. Les tests de performance aident les testeurs à s’assurer que les logiciels sont de haute qualité et qu’ils sont rapides, stables et fiables.
2. Tests de résistance
Les tests de stress sont un type de tests non fonctionnels qui évaluent les performances du logiciel lorsqu’il est soumis à des contraintes anormales. Il peut s’agir de tester les performances du logiciel lorsque quelqu’un essaie d’utiliser un grand nombre de fonctions différentes en même temps, ou lorsqu’il exécute de nombreuses autres applications en même temps.
Les tests de stress visent à identifier la limite à partir de laquelle le logiciel cesse de fonctionner correctement et ce qui se passe lorsque le système est soumis à des contraintes. Il permet aux testeurs de comprendre si le système peut se rétablir de lui-même et s’il informe les utilisateurs au moyen d’un message d’erreur approprié.
3. Essais de charge
Le test de charge est un type de test qui évalue le comportement d’un logiciel dans des conditions normales et lorsqu’il est soumis à des charges plus lourdes. Il sert à déterminer la quantité de données que le logiciel peut traiter simultanément sans que les performances en soient affectées.
Les tests de charge peuvent être utilisés pour tester le fonctionnement des applications lorsque de nombreux utilisateurs les utilisent en même temps ou lorsque les utilisateurs essaient de télécharger de nombreuses données en même temps.
Les tests de charge sont importants si vous voulez vérifier si votre logiciel est évolutif.
4. Tests de sécurité
Les tests de sécurité évaluent les applications logicielles et recherchent les failles dans la sécurité du logiciel. Il s’agit notamment des risques de sécurité potentiels qui pourraient entraîner une perte de données ou des violations qui exposent des données confidentielles.
Les tests de sécurité sont importants car ils permettent de s’assurer que le produit est correctement protégé contre le piratage, les violations de données et d’autres menaces externes pour la sécurité.
Parmi les tests de sécurité que les testeurs peuvent effectuer, on peut citer les audits de sécurité, le piratage éthique, les tests de pénétration, les analyses de sécurité et les évaluations de la posture.
5. Tests de mise à niveau et d’installation
Les tests de mise à niveau et d’installation sont un type de test de logiciel non fonctionnel qui vérifie le fonctionnement du logiciel sur différentes machines.
L’objectif de ce type de test est de s’assurer que les nouveaux utilisateurs peuvent facilement installer le logiciel sur leurs machines et que les utilisateurs existants peuvent le mettre à jour lorsque de nouvelles mises à jour sont publiées.
Les tests de mise à niveau et d’installation sont importants car les utilisateurs finaux doivent être en mesure d’installer facilement votre produit à condition qu’ils travaillent sur une machine compatible.
6. Tests de volume
Le test de volume est un type de test qui permet de vérifier ce qui se passe lorsque de grands volumes de données sont ajoutés à la base de données en une seule fois. Il s’agit de déterminer si l’application peut traiter de gros volumes de données et ce qui arrive au système si ce n’est pas le cas.
Les tests de volume sont également connus sous le nom de tests d’inondation, et vous pouvez les utiliser pour évaluer la perte de données et les messages d’erreur qui se produisent lorsque des quantités importantes de données sont ajoutées au système.
Les tests de volume sont le seul moyen de s’assurer que le logiciel peut gérer les volumes de données que les utilisateurs attendront de lui.
7. Tests de récupération
Les tests de récupération consistent à forcer le système logiciel à tomber en panne afin de tester la capacité du système à se rétablir après une panne.
Les tests de récupération peuvent aider les testeurs à comprendre comment les logiciels récupèrent les données et évitent les pertes si le matériel est débranché pendant l’utilisation, si le logiciel est déconnecté du réseau pendant un transfert de données ou si vous redémarrez le système de manière inattendue.
Ce type de test est important, car les systèmes dépourvus de protocoles de récupération adéquats peuvent subir de graves pertes de données lorsque des accidents de ce type se produisent.
Ce dont vous avez besoin pour commencer les tests non fonctionnels
Avant de commencer les tests non fonctionnels, vous devez vous assurer que vous avez préparé l’environnement de test et rassemblé les outils et les données dont vous avez besoin.
1. Plan de test
Avant de commencer les tests non fonctionnels, assurez-vous que vous disposez d’un plan de test terminé et signé par les personnes appropriées.
Votre plan de test doit contenir tous les détails pertinents sur ce que vous allez tester et sur la manière dont vous allez le faire. Il doit expliquer quand vous allez utiliser des tests manuels et quand vous allez utiliser des tests automatisés, et définir les rôles et les responsabilités de toutes les personnes impliquées dans le processus de test.
2. Cas de test
Avant de pouvoir exécuter des tests non fonctionnels, vous devez créer des scénarios de test. Chaque scénario de test décrit un élément spécifique que vous allez tester, explique comment vous allez le tester et décrit le résultat attendu du test.
Par exemple, si vous effectuez des tests de charge, un exemple de scénario de test peut consister à tester le comportement du logiciel lorsque dix utilisateurs utilisent le même module en même temps.
3. Vérification fonctionnelle
Il n’est pas possible d’effectuer des tests non fonctionnels sur des composants logiciels s’ils ne sont pas fonctionnels.
Par exemple, si vous voulez tester le nombre d’utilisateurs que le logiciel peut gérer en se connectant en même temps, il est d’abord important de vérifier que les utilisateurs individuels peuvent effectivement se connecter au logiciel.
Avant de commencer les tests non fonctionnels, assurez-vous que tous vos tests fonctionnels ont été réussis et que votre logiciel fonctionne comme vous l’attendez.
Cela signifie généralement que les tests de fumée, les tests d’intégrité, les tests unitaires, les tests d’intégration et les tests fonctionnels du système ont déjà été effectués.
4. Outils de test
Avant de commencer les tests non fonctionnels, rassemblez tous les outils de test que vous souhaitez utiliser pour réaliser vos tests.
Que vous utilisiez des outils d’automatisation pour partiellement automatiser certains de vos tests ou des outils de documentation pour vous aider à gérer et à stocker les rapports de test en vue d’une utilisation ultérieure, assurez-vous que les outils que vous souhaitez utiliser sont disponibles et prêts à l’emploi, et que tous les membres de l’équipe de test savent comment utiliser chaque outil correctement.
5. Environnement d’essai
Mettez en place l’environnement de test avant de commencer les tests non fonctionnels. Vous disposez peut-être déjà d’un environnement de test approprié, en particulier si vous pouvez utiliser le même environnement pour les tests de systèmes non fonctionnels et les tests de systèmes fonctionnels.
L’environnement d’essai idéal vous permet de tester tous les éléments dont vous avez besoin sur les appareils appropriés.
Par exemple, si vous testez la gestion du volume sur les smartphones, il est préférable de le faire sur un smartphone réel plutôt que d’essayer d’émuler un environnement mobile sur un ordinateur de bureau.
Le processus de test non fonctionnel
Le test des aspects non fonctionnels d’un logiciel est un processus en plusieurs étapes qui implique la préparation de l’environnement de test, la création de cas de test, la collecte de données de test et l’exécution de tests non fonctionnels.
Il est possible de décomposer le processus de test en petits morceaux afin de le rendre plus facile à suivre pour les débutants en matière de tests non fonctionnels.
1. Contrôles de l’état de préparation des tests non fonctionnels
Avant de commencer les tests non fonctionnels, il est important de vérifier que vous êtes prêt pour cette phase de test.
Il peut s’agir d’évaluer les critères de sortie de la dernière phase de test afin de s’assurer que le logiciel l’a réussie et de s’assurer que le logiciel a réussi tous les tests fonctionnels requis avant que les tests non fonctionnels n’aient lieu.
Certaines équipes peuvent créer des critères d’entrée pour les tests non fonctionnels, qui comprennent toutes les conditions qui doivent être remplies avant le début des tests non fonctionnels.
2. Créer un plan de test
Vous avez peut-être déjà réalisé cette étape si vous effectuez des tests non fonctionnels dans le cadre des tests du système et si vous suivez votre plan de test du système. Un plan de test décrit tous les tests que vous devez effectuer et la manière dont vous avez l’intention de les réaliser.
Sans un plan de test clair, il est facile de perdre de vue la portée et les objectifs des tests que vous effectuez.
3. Créer des cas de test
L’étape suivante des tests non fonctionnels consiste à créer des cas de test conçus pour tester chaque paramètre non fonctionnel du logiciel.
Chaque cas de test doit avoir un identifiant, un nom, une description et des détails sur le résultat attendu du test ainsi que tout critère de réussite ou d’échec déterminé à l’avance. Cela aide les testeurs à comprendre comment effectuer chaque test et quels sont les résultats à attendre.
4. Recueillir des données d’essai
Avant d’exécuter chaque scénario de test, vous devez rassembler les données de test que vous utiliserez pour chaque scénario de test.
Il s’agit généralement de collecter le code et les données des différents modules et composants qui constituent les fonctions et les domaines que vous allez tester. Pour maximiser la couverture des tests, vous devez disposer d’un grand nombre de données de test.
5. Préparer l’environnement de test
L’étape suivante des tests non fonctionnels consiste à préparer l’environnement de test. L’environnement de test est un serveur de test que vous utiliserez pour effectuer des tests de logiciels de différents types.
Il vous permet de créer des conditions identiques pour tester votre logiciel et de mettre en place différentes configurations pour les tests de configuration, les tests de sécurité et d’autres types de tests non fonctionnels.
6. Exécuter des tests non fonctionnels
Une fois l’environnement de test prêt, il est temps d’exécuter les tests non fonctionnels. Vous pouvez décider d’exécuter les tests par ordre de type, par exemple en commençant par les tests de performance avant de passer aux tests de sécurité et à d’autres types de tests non fonctionnels.
Au fur et à mesure que vous effectuez chaque test, notez les résultats dans votre rapport de test. Si vous automatisez des tests, votre outil d’automatisation disposera également d’une méthode normalisée pour communiquer les résultats de manière claire et sans ambiguïté.
7. Rapport sur les résultats des essais
Après avoir exécuté chaque cas de test, compilez les résultats de vos tests non fonctionnels dans un rapport unique.
Ce rapport doit indiquer clairement les résultats de chaque test et préciser sans ambiguïté si chaque test a été réussi ou non.
Suivez une structure standardisée pour votre rapport d’essai afin de vous assurer que toutes les informations que vous devrez transmettre sont incluses.
8. Corriger les défauts
Une fois les résultats des tests obtenus, remettez le logiciel aux développeurs si les tests ont échoué ou si vous avez identifié des bogues non fonctionnels qui doivent être corrigés.
Par exemple, si le logiciel ne gère pas un nombre suffisant d’utilisateurs en même temps ou si les performances ralentissent trop lorsque plusieurs programmes sont exécutés simultanément, ces problèmes devront probablement être corrigés dans le code pour que les utilisateurs soient satisfaits du produit.
9. Répéter le cycle de test
Une fois que les développeurs ont corrigé les défauts constatés lors de la phase initiale de tests non fonctionnels, le cycle de tests peut recommencer.
Les développeurs testent les modifications qu’ils apportent et transmettent la nouvelle version aux testeurs de l’assurance qualité, qui effectuent alors l’ensemble des tests, en commençant par les tests de fumée, les tests unitaires, les tests d’intégration et, enfin, les tests du système.
Le cycle de test est répété jusqu’à ce qu’il n’y ait plus de bogues ou de défauts à aucun endroit, après quoi la version peut passer à l’étape finale du test : le test d’acceptation par l’utilisateur.
Cas de test pour les tests non fonctionnels
Les scénarios de test sont un aspect important de tous les tests de logiciels, et lorsque vous effectuez des tests fonctionnels et non fonctionnels, vous utilisez des scénarios de test pour définir ce que vous allez tester et comment vous allez le tester.
Chaque cas de test peut être considéré comme un mini-test, et chaque cas de test aura ses propres sorties et résultats définis.
1. Que sont les cas de test pour les tests non fonctionnels ?
Un cas de test est un ensemble d’actions effectuées sur un logiciel afin de vérifier s’il satisfait aux conditions définies dans le plan du logiciel. Chaque cas de test indique effectivement aux testeurs ce qu’il faut tester et comment, et est conçu pour tester une fonction spécifique ou une caractéristique non fonctionnelle de l’application logicielle.
Les cas de tests non fonctionnels peuvent inclure des tests sur ce qui se passe lorsque quelqu’un essaie d’accéder à des données sécurisées dans le système ou des tests sur la rapidité de chargement du logiciel au démarrage.
2. Comment concevoir des cas de test non fonctionnels ?
Lorsque vous concevez des cas de test pour les tests non fonctionnels, il est important de suivre les pratiques standard des cas de test tout en gardant à l’esprit les objectifs de vos tests non fonctionnels.
Suivez les étapes ci-dessous pour rédiger des scénarios de tests non fonctionnels qui décrivent clairement ce que vos testeurs doivent faire pour réaliser chaque test.
1. Définir la zone à couvrir
Pour chaque scénario de test, réfléchissez à la partie de votre logiciel qu’il va couvrir.
Par exemple, si vous rédigez des scénarios de test pour l’installation et la mise à jour, vous pouvez inclure des scénarios de test qui évaluent la facilité d’installation de l’application sur différents appareils et le temps nécessaire pour mettre à jour le logiciel à l’aide d’un nouveau correctif.
2. Créer un identifiant unique pour le cas de test
Chaque scénario de test doit avoir un numéro d’identification unique. Cela permet de retrouver facilement la description du cas de test et les résultats par la suite et d’éviter toute confusion sur le cas de test auquel vous faites référence si deux cas de test ont des noms ou des descriptions similaires.
3. Nommez et décrivez chaque test
Bien que l’ID du scénario de test identifie le test, vous devrez également fournir un nom et une description pour chaque scénario de test que vous écrivez.
Il doit s’agir d’un nom simple qui résume ce que vous testez, tandis que la description est une simple phrase qui donne un peu plus de détails.
La description doit être suffisamment claire pour que les testeurs sachent ce qu’il faut tester et comment le tester, ainsi que les conditions particulières qui doivent être remplies lors du test.
4. Spécifier le résultat attendu
Pour chaque cas de test, décrivez le résultat qui devrait se produire si le logiciel fonctionne comme prévu.
Dans les tests non fonctionnels tels que les tests de performance et les tests de charge, cela peut signifier dans de nombreux cas que le logiciel continue simplement à fonctionner normalement sans ralentissement, décalage ou panne.
Dans d’autres cas, cela peut signifier que des messages d’erreur particuliers apparaissent pour informer l’utilisateur du problème et recommander une solution.
5. Recommander des techniques de test
Pour chaque cas de test, recommandez le type de techniques de test et d’outils de test non fonctionnels que vous pensez que le testeur devrait utiliser pendant le test.
Dans les tests non fonctionnels, les testeurs peuvent utiliser des approches très différentes pour différents types de tests.
Par exemple, les tests de charge et les tests de stress peuvent nécessiter une automatisation parce qu’il n’est pas pratique de simuler manuellement un trafic extrêmement important, alors que d’autres types de tests peuvent être plus faciles à réaliser sans outils ou technologies spécifiques.
6. Faire évaluer chaque cas de test par des pairs
Avant d’approuver chaque cas de test, faites-le examiner par une personne avec laquelle vous travaillez. Il peut s’agir d’un autre testeur ou d’un responsable de l’assurance qualité.
L’examen par les pairs des cas de test permet de s’assurer qu’ils sont suffisamment clairs pour être suivis par un testeur tiers et qu’ils ne comportent pas d’ambiguïtés ou d’erreurs susceptibles d’entraîner des tests incorrects.
3. Exemples de cas de tests non fonctionnels
Si vous écrivez des cas de test pour des tests non fonctionnels, ils peuvent ressembler aux exemples de tests non fonctionnels ci-dessous.
Exemple de test d’évolutivité
ID du cas de test : 6671
Nom du scénario de test : Test de connexion d’utilisateurs multiples
Description : Emuler plus de 20 utilisateurs se connectant au logiciel en même temps à l’aide d’outils d’automatisation.
Résultats attendus : Le logiciel devrait fonctionner normalement pour chaque utilisateur, permettant à chaque utilisateur de se connecter avec succès en moins de 5 secondes.
Exemple de test de compatibilité
ID du cas de test : 5214
Nom du cas de test : Chargement de l’application dans le navigateur Opera
Description : Charger l’application dans le navigateur web Opera.
Résultats attendus : L’application se charge normalement dans le navigateur web Opera avec une résolution d’affichage et une mise en page standard.
Tests non fonctionnels manuels ou automatisés ?
Lorsque vous choisissez entre différentes techniques de tests non fonctionnels, vous devez décider si vous souhaitez effectuer des tests non fonctionnels manuels ou automatisés.
Les tests manuels sont réalisés par des testeurs humains, ce qui signifie qu’ils prennent généralement plus de temps, mais ils offrent également des possibilités de tests exploratoires.
Les tests non fonctionnels automatisés sont plus rapides et, d’une certaine manière, plus fiables, mais ils nécessitent également plus de ressources ou d’outils. L’automatisation et l’hyperautomatisation deviennent de plus en plus populaires dans le domaine des tests, en particulier lorsqu’il s’agit de tests non fonctionnels.
Tests manuels non fonctionnels : Avantages, défis et processus
Les tests non fonctionnels manuels sont effectués uniquement par des testeurs, qui testent chaque élément non fonctionnel de manière indépendante.
Lors de la réalisation de tests non fonctionnels manuels, les testeurs doivent recueillir des informations sur le logiciel, créer des cas de test individuels correspondant au plan de test et exécuter ces cas de test manuellement.
Cela prend beaucoup de temps, mais cela signifie aussi que les testeurs AQ ont la liberté de déterminer ce qui est testé et comment.
1. Voici quelques-uns des avantages des tests manuels :
● Les tests manuels peuvent être moins coûteux que les tests automatisés car ils ne nécessitent pas de technologies ou de connaissances techniques spécifiques.
● Les tests manuels permettent aux testeurs d’offrir un aperçu humain et de la subjectivité sur la façon dont le logiciel fonctionne et s’il fonctionne de manière satisfaisante.
● Les tests manuels peuvent être utilisés pour effectuer des tests de système dans des scénarios où il est impossible d’automatiser.
● Les tests manuels permettent aux testeurs d’évaluer les aspects visuels du système, tels que l’interface graphique et d’autres facteurs susceptibles d’affecter la facilité d’utilisation.
● Les tests manuels offrent aux testeurs une perspective plus large du système dans son ensemble et de la manière dont les différents modules et composants fonctionnent ensemble.
Cependant, les tests manuels présentent également des inconvénients.
2. Voici quelques-uns des défis posés par les tests manuels :
● Certains types de tests non fonctionnels, notamment les tests de charge et les tests de performance, ne sont pas pratiques à réaliser manuellement.
● Les tests manuels prennent beaucoup plus de temps que les tests non fonctionnels automatisés.
● Les testeurs manuels peuvent être distraits, perdre leur concentration et commettre des erreurs, en particulier lorsqu’ils effectuent des tâches de test très répétitives.
Tests non fonctionnels automatisés : Avantages, défis et processus
Les tests non fonctionnels automatisés sont réalisés à l’aide de scripts et d’outils de test automatisés. En utilisant des méthodes de tests automatisés, les testeurs peuvent effectuer des tests en arrière-plan tout en vaquant à d’autres tâches, une fois que les tests automatisés ont été lancés.
1. Voici quelques-uns des avantages de l’automatisation des tests non fonctionnels :
1. Économiser du temps et des ressources en réduisant le temps consacré à des tâches longues et fastidieuses.
2. L’automatisation permet d’augmenter la couverture des tests en couvrant un plus grand nombre de composants et de fonctionnalités.
3. Il est plus facile d’effectuer des tests automatisés fréquemment parce qu’ils prennent moins de temps à réaliser.
4. Les tests automatisés sont idéaux pour les tâches de test qui prennent du temps, comme les tests de charge, les tests de volume et les tests de stress, qui sont très difficiles à réaliser manuellement.
5. Le risque d’erreur est plus faible lors de la réalisation de tests automatisés.
Cependant, les tests automatisés présentent également certains inconvénients, ce qui signifie qu’ils ne constituent pas toujours la bonne approche pour tous les types de tests non fonctionnels.
2. Voici quelques-uns des défis posés par les tests non fonctionnels automatisés :
1. La mise en place de tests automatisés est plus coûteuse que celle de tests manuels.
2. La mise en place de l’automatisation des tests peut prendre du temps et des ressources techniques.
3. L’automatisation des tests ne laisse pas de place aux tests exploratoires
4. L’automatisation des tests nécessite encore du temps pour la création des cas de test.
Conclusion : Manuel ou automatisé
les tests non fonctionnels ?
Dans la plupart des types de tests de logiciels, la combinaison de tests manuels et automatisés offre généralement les meilleurs résultats. Les équipes de test peuvent ainsi bénéficier de l’efficacité, de la fiabilité et de la précision des tests automatisés, tout en effectuant des tests exploratoires qui permettent aux testeurs d’évaluer les logiciels d’un point de vue plus subjectif.
Dans les tests non fonctionnels, les tests manuels et automatisés sont pratiquement nécessaires pour la plupart des équipes de test.
Les tests manuels sont utilisés de préférence pour effectuer des tests non fonctionnels tels que les tests d’utilisabilité, tandis que les tests automatisés sont le plus souvent utilisés pour effectuer des tests qui prendraient trop de temps et seraient trop difficiles à réaliser manuellement, tels que les tests de stress ou les tests de volume.
Les tests non fonctionnels sont l’un des domaines les plus évidents pour utiliser les techniques d’automatisation des tests, car il s’agit d’un type de test quantitatif et mesurable qui ne demande pas de résultats subjectifs.
Comme pour les autres types de tests, les tests non fonctionnels sont généralement réalisés à l’aide d’une combinaison de tests manuels et de tests automatisés.
Cependant, les tests automatisés sont pratiquement nécessaires pour de nombreux types de tests non fonctionnels, et les paramètres et métriques des tests non fonctionnels signifient que l’automatisation est plus adaptée à ce type de tests qu’aux tests fonctionnels.
Meilleures pratiques pour les tests non fonctionnels
Lorsque vous entreprenez des tests non fonctionnels pour la première fois, le respect des meilleures pratiques de test peut vous aider à normaliser votre processus de test et à optimiser l’efficacité de vos tests.
Les meilleures pratiques servent de lignes directrices aux équipes de test de logiciels qui souhaitent améliorer les processus de test et s’aligner sur les normes de l’industrie.
1. Utiliser des outils d’automatisation
Dans les tests non fonctionnels plus que dans les autres types de tests, il est important d’utiliser des outils d’automatisation pour automatiser certains types de tests, en particulier les tests de volume, les tests de stress et les tests de charge.
Ces types de tests permettent généralement de vérifier le fonctionnement des logiciels sous la pression des utilisateurs, des données et du trafic, ce qui peut être très difficile à reproduire manuellement.
L’automatisation de ces types de tests non fonctionnels sera non seulement plus efficace, mais aussi plus précise et permettra aux testeurs de reproduire facilement des charges et des contraintes plus élevées.
2. Examen par les pairs de l’ensemble de la documentation
En plus de demander à vos pairs de réviser les cas de test que vous créez, demandez à vos pairs au sein de votre équipe de test de réviser les rapports de bogues, les rapports de test, les plans de test et les autres formes de documentation formelle créées au cours du processus de test.
Cela réduit le risque de petites erreurs qui pourraient entraîner des retards importants dans le processus d’essai et de développement.
3. Définir des exigences mesurables
Lorsque vous définissez les exigences de votre logiciel avant le début des tests non fonctionnels, assurez-vous que chaque exigence est objective et mesurable.
Cela permet aux testeurs de vérifier plus facilement si le logiciel répond à ces exigences lors des tests et ne laisse aucune place à l’interprétation.
Qu’est-ce qui est considéré comme « rapide » ou « efficace » ? Utilisez des chiffres et des valeurs quantitatives pour définir ce que vous recherchez.
4. Étudier attentivement les paramètres de l’essai
Avant de décider quels indicateurs vous allez utiliser pour mesurer la performance de votre logiciel, réfléchissez à ce que voudront les utilisateurs du logiciel et aux indicateurs qui correspondent réellement au plan et aux exigences du logiciel.
La plupart des logiciels doivent être rapides et fiables, mais quels autres critères vos utilisateurs peuvent-ils rechercher ? Existe-t-il des indicateurs spécifiques aux logiciels que vous devriez prendre en compte au cours du processus de test ?
Types de résultats d’un test non fonctionnel
Lorsque vous effectuez des tests non fonctionnels, vous obtenez différents types de résultats.
Ceux-ci sont généralement très différents des résultats des tests fonctionnels, qui sont souvent plus clairs, car les tests fonctionnels se contentent de vérifier si une fonction fonctionne comme elle le devrait ou non.
Comme pour les tests fonctionnels, les testeurs doivent définir des attentes claires pour chaque cas de test, ce qui permet de déterminer facilement si le test est réussi ou non.
1. Les nombres absolus
Lorsque vous effectuez des tests de performance, des tests de résistance et d’autres types de tests non fonctionnels, les résultats que vous recherchez le plus souvent sont des vitesses et d’autres chiffres absolus.
Les tests de performance permettent de vérifier la rapidité avec laquelle le système peut effectuer certaines tâches, ce qui se mesure en secondes ou en millisecondes.
Si vous effectuez des tests de charge, vous pouvez évaluer la quantité de données que le logiciel peut traiter en même temps sans plantage ou retard.
2. Messages d’erreur
Les tests non fonctionnels vérifient également le fonctionnement du système en cas d’erreurs, telles que les erreurs de sécurité, de validation et de configuration.
Il est important que les systèmes affichent des messages d’erreur précis et clairs lorsque des erreurs se produisent, afin que les utilisateurs puissent prendre des mesures pour corriger le problème et continuer à utiliser le logiciel.
Des messages d’erreur doivent également apparaître lors des tests de sécurité lorsque le système empêche les utilisateurs d’enfreindre les dispositifs de sécurité intégrés au logiciel.
3. Crashs
Un plantage est un signe de défaillance du système, et il indique généralement que le système n’est pas en mesure de fonctionner au niveau que vous testez et peut signifier que le test est réussi.
Dans certains cas, le système peut se bloquer tout en réussissant le cas de test sur lequel vous travaillez, par exemple, si le système résiste à la quantité de stress ou de trafic requise avant de se bloquer.
Lors des tests non fonctionnels, les testeurs doivent s’attendre à ce que le système tombe régulièrement en panne, en particulier lorsqu’ils le poussent à ses limites dans le cadre de tests de stress et d’autres tests de performance.
Exemples de tests non fonctionnels
Les exemples de tests non fonctionnels sont similaires aux exemples ci-dessus pour les cas de tests non fonctionnels.
Vous pouvez consulter des exemples de tests non fonctionnels pour mieux comprendre ce que sont les tests non fonctionnels et ce qu’ils testent au sein d’une application logicielle.
1. Exemple de test de performance
Si vous travaillez sur une application mobile qui connecte les utilisateurs à une base de données en ligne, il est important qu’un grand nombre d’utilisateurs puissent accéder à cette base de données et en télécharger les données en même temps.
Il s’agit également d’un élément clé des tests d’évolutivité, en particulier si vous souhaitez augmenter le nombre d’utilisateurs de l’application à l’avenir.
Vous testerez ensuite la réaction du système lorsque, par exemple, 1 000 utilisateurs tentent d’accéder à la même base de données en même temps, et vous fixerez des exigences quant à la vitesse de chargement de l’application dans ces conditions.
2. Tests de compatibilité
Si vous testez une nouvelle application de gestion documentaire, vous devrez vérifier qu’elle fonctionne sur tous les appareils auxquels elle est destinée.
Cela signifie que vous pouvez tester l’installation et le chargement de l’application sur toutes les versions les plus récentes de Windows, Mac et tout autre système d’exploitation (tel que Linux) avec lequel vous souhaitez que le logiciel soit compatible.
3. Tests de sécurité
Lorsque vous effectuez des tests de sécurité, vous testez certains des moyens par lesquels des personnes peuvent tenter d’accéder à des données confidentielles ou d’enfreindre les mesures de sécurité du logiciel, afin de vérifier que le système se comporte comme vous l’attendez dans ces situations.
Par exemple, vous pouvez vous connecter en tant qu’utilisateur et essayer d’accéder à des fichiers pour lesquels vous n’avez pas d’autorisation de sécurité afin de vous assurer que le système ne vous permet pas d’accéder à ces fichiers.
Types d’erreurs et de bogues détectés
par des tests non fonctionnels
Les tests non fonctionnels peuvent révéler un grand nombre de bogues et de défauts qui ne sont pas aussi faciles à trouver que ceux identifiés lors des tests fonctionnels. En effet, les tests non fonctionnels exigent souvent que les testeurs vérifient différentes configurations, mises en place et combinaisons de conditions afin d’évaluer les performances du système dans une myriade d’environnements différents.
1. Défauts de performance
Les défauts de performance surviennent lorsque le système fonctionne, mais pas aussi rapidement ou efficacement que prévu.
Par exemple, vous pouvez constater que le système ne se charge pas assez rapidement dans certaines conditions ou même qu’il se bloque si un trop grand nombre d’utilisateurs se connectent en même temps.
Les défauts de performance n’empêchent pas complètement les gens d’utiliser votre logiciel, mais ils peuvent rendre votre logiciel moins utilisable et moins susceptible de répondre aux besoins des utilisateurs.
2. Défauts de sécurité
Les défauts de sécurité sont ceux qui ont un impact sur la sécurité de votre système logiciel et des données qui y sont stockées.
Des défauts de sécurité peuvent survenir si, par exemple, des utilisateurs peuvent accéder à des données confidentielles auxquelles ils ne devraient pas avoir accès, si certaines parties de l’application ne sont pas correctement protégées par un mot de passe ou si le cryptage échoue.
Celles-ci peuvent entraîner des failles de sécurité qui peuvent avoir un impact sérieux sur la réputation d’un éditeur de logiciels.
3. Défauts fonctionnels
Bien que les tests non fonctionnels ne soient pas conçus pour tester les fonctions d’une application logicielle, ils permettent dans certains cas d’identifier des défauts fonctionnels dans le logiciel.
Par exemple, l’objectif du test de fiabilité n’est pas de vérifier si l’application fonctionne, mais de vérifier si l’application fonctionne de manière fiable lors d’essais répétés.
Cela peut révéler que certaines caractéristiques ne fonctionnent pas correctement de manière fiable lorsqu’une action est répétée, ce qui peut être considéré comme des erreurs fonctionnelles.
Mesures communes pour les tests non fonctionnels
Les paramètres des tests non fonctionnels décrivent les paramètres qui permettent de mesurer la performance et l’efficacité du système.
Les différents types de tests non fonctionnels s’appuient sur des mesures différentes, et vous pouvez choisir d’utiliser une variété de mesures en fonction des objectifs finaux du projet.
1. Temps
Les indicateurs de temps mesurent le temps nécessaire à l’exécution de certaines tâches ou le temps d’attente des utilisateurs pour le chargement des fonctions.
Le nombre de transactions ou de téléchargements qu’une application peut effectuer dans un laps de temps donné, les temps de réponse des différentes fonctions et le temps nécessaire à l’application pour effectuer une opération particulière sont autant d’exemples de mesures du temps.
Les différents types de tests mesurent les résultats en secondes ou sous forme de présentation du nombre d’opérations par seconde.
2. Espace
L’espace est une autre mesure importante dans les tests non fonctionnels. Les mesures d’espace peuvent tester l’espace dont le système a besoin au niveau de l’unité centrale ou l’espace que le logiciel occupe sur le disque dur une fois qu’il est complètement installé.
La mémoire cache, la mémoire principale et la mémoire auxiliaire sont des exemples de mesures de l’espace.
Les logiciels qui nécessitent beaucoup d’espace pour fonctionner correctement peuvent convenir à un plus petit nombre de clients.
3. Facilité d’utilisation
Certains paramètres des tests non fonctionnels prennent en compte la facilité d’utilisation du système, par exemple le temps nécessaire pour former les utilisateurs à une utilisation correcte du système, le nombre de choix que les utilisateurs doivent parcourir pour exécuter des fonctions clés, ou le nombre de clics de souris nécessaires pour effectuer certaines tâches.
Les tests non fonctionnels permettent de mesurer quantitativement chacun de ces paramètres, les chiffres les plus bas impliquant généralement des niveaux d’utilisabilité plus élevés.
4. Fiabilité
La fiabilité est une autre mesure importante dans les tests non fonctionnels. La fiabilité reflète la probabilité que le système se comporte toujours de la même manière ou qu’il fonctionne comme il se doit pendant une longue période.
Le temps moyen avant défaillance, le taux de défaillance, la disponibilité et la probabilité d’indisponibilité sont quelques exemples de paramètres utilisés pour mesurer la fiabilité.
Chacune de ces mesures aide les testeurs à vérifier que le système peut fonctionner pendant une longue période sans connaître de défaillances ou de pannes.
5. Robustesse
La robustesse est la mesure de la capacité du système à gérer les défaillances et à se rétablir en cas de défaillance.
Parmi les exemples d’indicateurs mesurant la robustesse, citons le temps nécessaire au système pour se rétablir après une panne, le pourcentage d’incidents conduisant à une panne catastrophique et la probabilité que les fichiers de données soient corrompus après une panne du système.
Ces mesures sont importantes car les utilisateurs s’attendent à ce que les systèmes tombent parfois en panne sans perdre toutes les données ou corrompre les fichiers.
6. La portabilité
Les paramètres de portabilité mesurent la facilité avec laquelle le logiciel peut être transféré vers différents systèmes ou déplacé vers un nouvel emplacement au sein d’un réseau.
Le pourcentage de code non portable et le nombre de systèmes sur lesquels le logiciel peut fonctionner sont des exemples d’indicateurs qui mesurent la portabilité.
Idéalement, les logiciels qui peuvent fonctionner sur un grand nombre de systèmes différents sont plus portables et donc plus pratiques à utiliser dans des environnements qui peuvent nécessiter des transferts ou des déménagements fréquents.
Stratégies pour la réalisation de tests non fonctionnels
Lorsque vous commencez les tests non fonctionnels, il est important d’aborder cette phase de test avec une stratégie en tête. Les responsables de l’assurance qualité et les responsables des tests de logiciels doivent tenir compte des risques liés aux tests, des ressources dont ils disposent et de l’objectif des tests avant de commencer les tests non fonctionnels.
L’élaboration d’une stratégie peut vous aider à optimiser vos tests non fonctionnels dès le départ.
1. Attribuer les rôles et les responsabilités
Avant de commencer les tests non fonctionnels, attribuez les rôles et les responsabilités aux principaux membres de l’équipe de test. Il est ainsi plus facile de gérer la charge de travail des tests non fonctionnels et de s’assurer que des testeurs expérimentés sont responsables du maintien de la qualité et de l’efficacité des tests que vous réalisez.
Assurez-vous que les personnes que vous choisissez pour assumer ces fonctions possèdent les connaissances et l’expérience nécessaires pour mener à bien les tâches que vous attendez d’elles, en particulier si ces tâches requièrent des compétences techniques.
2. Rassembler les outils de test pertinents
Rassemblez toutes les technologies et tous les outils que vous souhaitez utiliser pour effectuer des tests non fonctionnels. Assurez-vous que tous les membres de votre équipe savent comment les utiliser efficacement et organisez des formations pour combler les lacunes en matière de compétences, le cas échéant.
S’assurer que tout le monde sait quels outils de test utiliser et comment les utiliser avant le début des tests non fonctionnels réduit le risque de devoir interrompre les tests ou les refaire en raison d’une connaissance insuffisante.
3. Établir des priorités pour les essais
Avant de commencer les tests non fonctionnels, dressez une liste de tous les aspects du système que vous devez tester et classez-les par ordre de priorité en fonction de leur urgence et de leur importance.
Vous pouvez classer les tests non fonctionnels par ordre de priorité en fonction du niveau de risque lié à chaque aspect du système que vous testez.
Par exemple, des tests de sécurité de base peuvent être effectués parce qu’une sécurité adéquate est considérée comme extrêmement importante dans les logiciels modernes. Plus vous identifiez tôt les défauts à haut risque, plus l’impact potentiel de ces défauts sur d’autres aspects du système est faible.
7 meilleurs outils de tests non fonctionnels
Les outils de test non fonctionnel peuvent rationaliser le processus de test, faciliter et rentabiliser l’automatisation des tests et aider les responsables de l’assurance qualité à gérer le processus de test et de documentation.
Il existe de nombreux outils de tests non fonctionnels gratuits disponibles en ligne, ainsi que certains outils pour lesquels vous pouvez payer une redevance mensuelle.
1. ZAPTEST édition FREE
ZAPTEST est un outil de test logiciel populaire qui permet aux utilisateurs d’effectuer des tests logiciels fonctionnels et non fonctionnels rapidement et facilement. Vous pouvez utiliser ZAPTEST pour automatiser les tests de logiciels et utiliser la technologie RPA pour émuler diverses fonctions et conditions dans les tests non fonctionnels.
L’édition FREE de ZAPTEST n’est qu’une version réduite de l’édition entreprise, offrant un grand nombre des mêmes fonctionnalités à plus petite échelle. Vous pouvez demander de l’aide sur le forum ZAPTEST et effectuer des tests de performance avec un nombre illimité d’utilisateurs virtuels.
2. Appium
Appium est un outil de test logiciel gratuit qui convient parfaitement pour tester les applications mobiles sur une variété de plateformes différentes, y compris les appareils iOS et Android. Appium offre aux utilisateurs une grande flexibilité pour concevoir leurs propres cadres et stratégies de test tout en bénéficiant des capacités d’automatisation offertes par Appium.
3. Loadium
Loadium est un outil de test non fonctionnel qui est mieux utilisé pour effectuer des tests de performance et des tests de charge, deux types de tests non fonctionnels qui sont beaucoup plus faciles à réaliser à l’aide d’outils d’automatisation.
Loadium permet aux utilisateurs d’effectuer des tests de charge à grande échelle et propose des solutions personnalisées afin que vous puissiez adapter vos tests aux objectifs de votre logiciel.
Vous pouvez essayer Loadium gratuitement ou payer pour télécharger la version complète de l’application.
4. Obkio
Obkio est un outil de test logiciel qui aide les responsables de l’assurance qualité et les responsables des tests à hiérarchiser et à classer les problèmes en fonction de leur gravité. Obkio peut détecter les problèmes avant que les utilisateurs ne les rencontrent, leur offrir des notifications intelligentes et les aider à déterminer où se situe le problème.
Obkio n’est pas seulement destiné aux tests non fonctionnels, mais c’est un outil de test gratuit très utile qui peut être utilisé à tous les stades du cycle de vie des tests.
5. SonarQube
SonarQube est un outil de test de sécurité open-source qui permet d’analyser automatiquement le code pour détecter les bogues et les vulnérabilités. Écrit en Java, SonarQube permet d’analyser le code dans plus de vingt langages de programmation différents. L’interface épurée du système facilite la détection des problèmes susceptibles d’entraîner des failles de sécurité à l’avenir.
6. Tsung
Tsung est un autre outil de test non fonctionnel idéal si vous souhaitez automatiser les tests de charge et de stress, mais que vous n’aimez pas la version gratuite de Loadium.
Tsung est un outil open-source qui permet aux utilisateurs d’effectuer des tests de charge à haut volume sur plusieurs protocoles et serveurs, y compris HTTP et SOAP.
Tsung est entièrement gratuit et peut aider les testeurs à s’assurer que le logiciel sur lequel ils travaillent offre des niveaux de performance élevés dans une variété de conditions difficiles.
7. Sikuli
Sikuli est une autre application qui utilise l’automatisation des processus robotiques pour automatiser le processus de test. L’application peut automatiser tout ce qui est visible à l’écran. Vous pouvez utiliser Sikuli pour tester des applications non basées sur le web et pour reproduire rapidement des bogues.
Liste de contrôle, conseils et astuces pour les tests non fonctionnels
Avant de commencer les tests non fonctionnels, vérifiez que vous disposez de tout ce dont vous avez besoin pour effectuer des tests non fonctionnels complets dans un environnement préparé.
Suivez la liste de contrôle ci-dessous pour obtenir des conseils et des astuces avant de commencer les tests non fonctionnels.
1. Travailler selon un calendrier
Que vous l’incluiez dans votre plan de test ou que vous créiez un document séparé, structurez vos tests logiciels autour d’un calendrier de test.
Si vous trouvez plus de bogues et de défauts que prévu, il se peut que vous vous écartiez parfois du calendrier, mais le fait d’avoir un calendrier au départ peut aider à guider les testeurs et à les motiver à travailler efficacement, en particulier lorsqu’ils effectuent des tests manuels qui prennent beaucoup de temps.
2. Identifier l’équipe de test
Déléguer des responsabilités et attribuer aux membres de votre équipe de test des rôles et des titres officiels peut contribuer à assurer le bon déroulement du processus de test.
Communiquez clairement les rôles et les responsabilités au sein de votre équipe avant le début des tests et confiez à différents testeurs la responsabilité de différents aspects des tests non fonctionnels afin que chacun soit tenu responsable de ses propres tâches.
3. Sélectionner les outils et les technologies avant les tests
Si vous ne décidez d’utiliser des outils et des technologies spécifiques qu’après avoir commencé les tests non fonctionnels, vous risquez de retarder le processus de test et de semer la confusion parmi les testeurs.
Au lieu de cela, faites vos recherches à l’avance et décidez s’il y a des outils que vous voulez utiliser avant le début des tests. Il est donc facile d’intégrer ces outils dans le plan de test et de former les testeurs à leur utilisation avant le début des tests.
4. Toujours obtenir l’approbation formelle des tests et de la documentation
Les tests sont un processus d’assurance qualité, et la meilleure façon de maximiser la valeur des tests que vous effectuez est d’effectuer une AQ de base sur les tests que vous planifiez et exécutez également.
Introduire des protocoles simples qui obligent les testeurs à demander aux responsables de l’assurance qualité et aux gestionnaires de revoir et de signer les plans et les rapports de test avant de passer à l’étape suivante.
Cela augmente considérablement les chances que les erreurs de test soient détectées et corrigées rapidement.
7 erreurs et pièges à éviter lors de la mise en œuvre de tests non fonctionnels
Si vous êtes novice en matière de tests non fonctionnels, il peut être facile de commettre certaines erreurs courantes dans lesquelles tombent souvent les testeurs et les professionnels de l’assurance qualité.
Les tests non fonctionnels sont un travail complexe qui implique d’examiner un logiciel sous tous les angles et toutes les perspectives.
Vous trouverez ci-dessous une liste des pièges les plus courants que les testeurs rencontrent lorsqu’ils effectuent des tests non fonctionnels.
1. Ne pas planifier
Si vous êtes novice en matière de tests non fonctionnels, vous pensez peut-être que vous pouvez vous lancer directement dans la phase de test sans créer au préalable un plan de test complet.
Certaines équipes de test peuvent élaborer des documents de test incomplets ou des résumés superficiels du plan de test qui ne décrivent pas correctement les actions que les testeurs doivent entreprendre pendant les tests non fonctionnels.
2. Mauvaise gestion des tests
Des problèmes peuvent survenir si les tests sont mal gérés à n’importe quel stade du processus de test. Une gestion inadéquate peut signifier que les testeurs ne disposent pas des ressources appropriées pour effectuer des tests en profondeur ou qu’ils ne disposent pas de suffisamment de temps pour tester chaque aspect de la construction.
Les gestionnaires de tests doivent être en mesure d’apprendre des erreurs qu’ils commettent et de développer des plans de tests plus efficaces pour l’avenir.
3. Mauvaise communication
Une mauvaise communication peut être à l’origine de nombreux problèmes au cours du processus de test, en particulier dans le cadre des tests non fonctionnels.
Il peut s’agir d’une mauvaise communication au sein de l’équipe de test ou d’une mauvaise communication entre les testeurs, les développeurs et les parties prenantes.
Cela se produit souvent lorsque les testeurs ne maintiennent pas les documents de test de manière adéquate ou ne communiquent pas régulièrement avec d’autres départements au cours du processus de test.
4. Ignorer les développeurs
Les testeurs et les développeurs travaillent généralement séparément, mais les équipes de testeurs qui travaillent en étroite collaboration avec les développeurs peuvent bénéficier d’une connaissance supplémentaire du fonctionnement du logiciel et de l’interaction entre les différents modules.
Impliquer les développeurs dans le processus de test, ou leur demander un retour d’information à des moments clés, peut aider les équipes de test à élaborer des plans de test plus efficaces et plus complets.
5. Objectif des tests
De nombreux testeurs pensent encore que l’objectif des tests est de vérifier que le logiciel fonctionne ou de démontrer aux parties prenantes et aux investisseurs que le logiciel fonctionne.
Au contraire, les testeurs devraient aborder les tests avec l’attitude que le but des tests est de rechercher des défauts.
Les testeurs qui ne trouvent pas de défauts ne peuvent se réjouir que le logiciel qu’ils testent soit exempt de bogues que s’ils sont convaincus d’avoir cherché partout où des défauts pourraient être trouvés.
6. Erreurs manuelles et erreurs d’automatisation
Il est important de prendre le temps de réfléchir à la question de savoir si les tests manuels ou les tests automatisés sont préférables pour chaque type de test que vous effectuez.
Les méthodes de test automatisées sont extrêmement bien adaptées à presque toutes les formes de tests non fonctionnels, et les équipes de test habituées aux tests fonctionnels peuvent commettre l’erreur de supposer qu’elles peuvent tester les caractéristiques non fonctionnelles manuellement tout aussi facilement.
7. Utiliser les mauvais outils de test
Il est facile de choisir les mauvais outils et technologies de test avant de commencer les tests non fonctionnels, surtout si les équipes de test sont habituées à effectuer des tests manuels et n’ont pas l’habitude d’utiliser des outils de test.
Recherchez à l’avance les méthodes de tests non fonctionnels que vous souhaitez utiliser et choisissez des outils logiciels et des outils d’automatisation qui répondent aux exigences spécifiques de votre projet.
Conclusion
Le test non fonctionnel est une étape essentielle du processus de test qui permet aux testeurs de vérifier les performances d’un système et la mesure dans laquelle il répond aux exigences non fonctionnelles telles que les temps de chargement, la capacité et la protection de la sécurité.
Il existe de nombreuses façons de réaliser des tests non fonctionnels, mais les outils d’automatisation modernes permettent de maximiser la couverture et la précision des tests sans compromettre la qualité des résultats.
FAQ et ressources
Si vous souhaitez en savoir plus sur les tests non fonctionnels, vous trouverez de nombreuses FAQ et ressources en ligne.
Parcourez nos ressources en ligne préférées sur les tests non fonctionnels ci-dessous ou lisez les réponses aux questions les plus fréquemment posées sur les tests non fonctionnels.
1. Les meilleurs cours sur les tests non fonctionnels
Il existe de nombreux cours en ligne qui peuvent vous aider à approfondir vos connaissances des méthodes et approches de tests non fonctionnels.
Certains de ces cours sont gratuits, tandis que d’autres peuvent donner lieu à la délivrance d’un certificat ou d’une qualification moyennant le paiement d’une redevance. Si vous souhaitez suivre un cours accrédité, vous pouvez demander à votre employeur de vous parrainer et de couvrir les frais de scolarité.
Voici quelques-uns des meilleurs cours sur les tests non fonctionnels :
- TSG : Formation non fonctionnelle 2 jours
- Udemy : Le Bootcamp complet de test logiciel 2023
- Edx : Certificat professionnel de test de logiciels
- Éducatif : Automatisation des tests de performance 101
2. Quelles sont les 5 principales questions d’entretien sur les tests non fonctionnels ?
Si vous vous préparez à un entretien d’embauche pour travailler dans le domaine des tests de logiciels, votre interlocuteur vous posera peut-être des questions sur les tests non fonctionnels afin de s’assurer que vous comprenez le fonctionnement de cette étape essentielle des tests de logiciels. Préparez votre entretien en préparant à l’avance des réponses efficaces aux questions les plus courantes.
● En quoi les approches et les méthodes que vous utilisez dans les tests non fonctionnels peuvent-elles différer des approches que vous utilisez dans les tests fonctionnels ?
● En quoi les tests non fonctionnels diffèrent-ils des tests fonctionnels ?
● Quels sont les différents types de tests non fonctionnels ?
● Comment hiérarchiser les tests fonctionnels et les cas de test ?
● À quelle étape des tests de logiciels les tests fonctionnels sont-ils généralement effectués ?
3. Les meilleurs tutoriels YouTube sur les tests non fonctionnels
Si vous préférez apprendre en regardant des vidéos, vous trouverez peut-être sur YouTube des tutoriels sur les tests non fonctionnels qui vous permettront d’en savoir plus sur ce type de tests de logiciels.
Vous trouverez ci-dessous quelques-uns des meilleurs tutoriels YouTube sur les tests de logiciels disponibles aujourd’hui.
Qu’est-ce qu’un test logiciel non fonctionnel ? Un tutoriel sur les tests de logiciels
Aide aux tests de logiciels : Tests non fonctionnels
Tests non fonctionnels dans les tests de logiciels
Visiter W3Schools
Tests fonctionnels et non fonctionnels
4. Comment maintenir les tests non fonctionnels
Une bonne maintenance des tests garantit que les tests de logiciels peuvent être répétés sans compromettre la qualité des résultats des tests.
En maintenant des tests non fonctionnels, vous pouvez vous assurer que les tests à chaque étape du processus de développement sont adéquats et que vos tests sont toujours mis à jour en fonction de l’évolution constante du code.
Vous pouvez maintenir des tests non fonctionnels en suivant les conseils ci-dessous.
● Communiquer clairement au sein de l’équipe de test lors de la création de cas de test et de la rédaction de la documentation.
● Toujours suivre les meilleures pratiques en matière de conception de tests.
● Réévaluer les protocoles de test à différentes étapes du processus de test.
● Mettre à jour les modifications apportées à votre test au fur et à mesure.
Prendre en compte les projets futurs lors de la modification des tests actuels
5. Les tests non fonctionnels sont-ils des tests boîte noire ou boîte blanche ?
Les tests non fonctionnels sont un type de tests en boîte noire, ce qui signifie que les testeurs ne s’intéressent pas au fonctionnement interne du système, mais uniquement à ses résultats externes.
Cela contraste avec les tests de la boîte blanche, qui testent la façon dont le système fonctionne en interne. Les tests unitaires et les tests d’intégration sont des exemples de tests en boîte blanche.
Les tests des exigences fonctionnelles et non fonctionnelles sont des exemples de tests en boîte noire. Cela signifie que les testeurs n’ont pas besoin de compétences techniques avancées ou de connaissances en programmation informatique pour effectuer des tests en boîte noire, ni d’apprendre à mettre en œuvre les systèmes qu’ils testent.
