Que sont les tests unitaires et les tests d’intégration, et quels autres types de tests dois-je connaître?

J’ai vu d’autres personnes mentionner plusieurs types de tests sur Stack Overflow.

Ceux dont je me souviens sont les tests unitaires et les tests d’intégration. En particulier, les tests unitaires sont souvent mentionnés. Quel est exactement le test unitaire? Qu’est-ce que le test d’intégration? Quelles autres techniques de test importantes dois-je connaître?

La programmation n’est pas mon métier, mais j’aimerais que ce soit un jour, tout ce qui concerne la production, etc.

Du haut de ma tête:

  • Tests unitaires dans le sens de “tester la plus petite unité isolable d’une application”; c’est généralement une méthode ou une classe, selon l’échelle.
  • Test d’intégration
  • Test de fonctionnalité : ceci peut couper à travers les unités et est au centre de TDD.
  • Test de la boîte noire : tester uniquement l’interface publique sans savoir comment fonctionne la chose.
  • Tests de boîtes de verre : tester toutes les parties d’une chose en toute connaissance de cause.
  • Tests de régression : des cas-tests construits pour reproduire des bogues, afin de s’assurer qu’ils ne réapparaîtront pas plus tard.
  • Tests inutiles : tester le même cas de base de plusieurs façons, ou tester des choses si simples qu’il n’est pas nécessaire de les tester (comme les getters et setters générés automatiquement)

dois-je être au courant de tout autre test important de mon code?

Voici quelques types de tests, en fonction des différentes phases du cycle de vie du logiciel:

  • Test unitaire : ce petit code fonctionne-t-il?
  • Suite de test unitaire : une séquence de nombreux tests unitaires (pour beaucoup de petits bits de code)
  • Test d’intégration : testez si deux composants fonctionnent ensemble lorsqu’ils sont combinés (ou intégrés)
  • Test système : teste si tous les composants fonctionnent ensemble lorsqu’ils sont combinés (ou intégrés)
  • Test d’acceptation : ce que le client fait pour décider s’il veut vous payer (le test du système détecte si le logiciel fonctionne comme prévu … le test d’acceptation découvre si le client est “tel que conçu”)

Il y a plus:

  • Test d’utilisabilité
  • Test de performance
  • Test de chargement
  • Test de stress

Et bien plus encore … le logiciel de test est un sujet aussi vaste que le logiciel d’écriture.

MSDN: Tests unitaires

Le principal objective des tests unitaires est de prendre le plus petit logiciel testable de l’application, de l’isoler du rest du code et de déterminer s’il se comporte exactement comme prévu. Chaque unité est testée séparément avant de les intégrer dans des modules pour tester les interfaces entre modules. Les tests unitaires ont prouvé leur valeur car un grand pourcentage de défauts est identifié lors de son utilisation.

MSDN: Tests d’intégration

Les tests d’intégration sont une extension logique des tests unitaires. Dans sa forme la plus simple, deux unités déjà testées sont combinées dans un composant et l’interface entre elles est testée. Un composant, en ce sens, fait référence à un agrégat intégré de plusieurs unités. Dans un scénario réaliste, de nombreuses unités sont combinées en composants, qui sont à leur tour agrégés dans des parties encore plus grandes du programme. L’idée est de tester des combinaisons de pièces et éventuellement d’étendre le processus pour tester vos modules avec ceux d’autres groupes. Finalement, tous les modules constituant un processus sont testés ensemble. Au-delà de cela, si le programme est composé de plusieurs processus, ils doivent être testés par paires plutôt que tous ensemble.

Consultez les sites pour plus d’informations. Il existe également de nombreuses informations provenant de sources autres que Microsoft.

L’autre technique importante est le test de régression . Dans cette technique, vous gérez une suite de tests (appelée suite de régression), qui sont généralement exécutés tous les soirs et avant chaque enregistrement. Chaque fois que vous avez un correctif de bogue, vous ajoutez un ou plusieurs tests à la suite. Le but est de vous empêcher de réintroduire les anciens bogues corrigés. (Le problème est étonnamment commun!)

Commencez à accumuler votre suite de régression avant que votre projet ne devienne trop gros, sinon vous le regretterez. J’en ai sûrement!

Il existe différents niveaux de test correspondant à la phase de développement du logiciel. Le niveau le plus élevé est l’parsing des exigences et le niveau le plus bas est la mise en œuvre de la solution.

Qu’est-ce que le test unitaire?

  • Les tests unitaires évaluent le logiciel en ce qui concerne sa mise en œuvre.
  • Nous nous concentrons sur le test des unités d’un programme (c.-à-d. Les méthodes individuelles) et ignorons qui appelle / utilise ces unités. Par conséquent, nous traitons essentiellement chaque unité comme une unité autonome.
  • Il existe de nombreux outils de test unitaire, l’un des plus populaires est JUnit.

  • Lors de la réalisation des tests unitaires, nous souhaitons créer un ensemble de tests (ensemble de cas de test) répondant à certains critères de couverture. Cela pourrait être des critères de couverture structurelle (NC, EC, PPC, etc.) ou des critères de stream de données (ADC, AUC, ADUPC, etc.).

  • Notez que le test unitaire est le niveau de test le plus bas car il évalue les unités de code réelles produites après la mise en œuvre. Ce type de test est effectué avant les tests d’intégration.
  • Des tests unitaires efficaces garantissent que les tests d’intégration ne seront pas douloureux, car il est moins coûteux et plus facile de détecter et de corriger les bogues lors des tests unitaires

Qu’est-ce que le test d’intégration?

  • Des tests d’intégration sont nécessaires pour garantir que nos logiciels fonctionnent toujours lorsque deux composants ou plus sont combinés.
  • Vous pouvez effectuer des tests d’intégration avant la fin du système.
  • Le problème d’ordre de test d’intégration de classe (CITO) est associé aux tests d’intégration. CITO a à voir avec la stratégie d’intégration des composants. Il existe de nombreuses solutions proposées à CITO, telles que l’intégration descendante, l’intégration ascendante, etc. . Notez que c’est encore un domaine de recherche actif!
  • Les tests d’intégration sont effectués après les tests unitaires.
  • Il arrive souvent que les composants individuels fonctionnent correctement, mais lorsque tout est mis en place, des bogues apparaissent soudainement en raison d’incompatibilités / problèmes avec les interfaces.

Les autres niveaux de test incluent:

  1. Les tests de régression

    • Ce type de test revêt une grande importance car les développeurs commettent souvent des modifications sur les logiciels. Nous voulons donc nous assurer que ces modifications n’introduisent pas de bogues.
    • La clé de l’efficacité des tests de régression est de limiter la taille des tests de régression afin de ne pas mettre trop de temps à terminer les tests, sinon l’ensemble de tests ne sera pas terminé avant la prochaine validation. Nous devons également choisir des cas de test efficaces qui ne manqueront pas de bugs.
    • Ce type de test devrait être automatisé.
    • Il est important de noter que nous pouvons toujours continuer à append plus de machines pour contrecarrer le nombre croissant de tests de régression, mais à un moment donné, le compromis ne vaut pas la peine.
  2. Test d’acceptation

    • Avec ces tests, nous évaluons les logiciels en fonction des exigences fournies. En gros, nous voyons si le logiciel que nous avons produit répond aux exigences qui nous ont été données.
    • C’est généralement le dernier type de test effectué dans la séquence des activités de développement logiciel. Par conséquent, ce type de test est effectué après les tests unitaires et les tests d’intégration.

Les tests unitaires sont simplement l’idée d’écrire (si tout va bien) de petits blocs de code pour tester des parties indépendantes de votre application.

Par exemple, vous pouvez avoir une application de calculasortingce et vous devez vous assurer que la fonction d’ajout fonctionne. Pour ce faire, vous écrivez une application distincte qui appelle directement la fonction d’addition. Ensuite, votre fonction de test évaluera le résultat pour voir s’il est conforme à vos attentes.

Il appelle essentiellement vos fonctions avec des entrées connues et la vérification de la sortie est exactement ce que vous attendiez.

Les deux premiers résultats de la recherche sur Google pour les «types de tests» semblent complets

Ceux que je pense sont les plus pertinents. Voir ici

C’était une entrée que j’ai écrite: Différents types de tests automatisés .

Test d’unité : Le test effectué sur une unité ou sur un plus petit logiciel. Fait pour vérifier si elle répond à ses spécifications fonctionnelles ou à la structure de conception prévue.

Test d’intégration: Test des modules associés pour leur fonctionnalité combinée.

Test de régression: test de l’application pour vérifier que les modifications n’ont pas provoqué d’effets inattendus.

Test de fumée : Le test de fumée est vérifié si la version est testable ou non.

Différents types de cas de test:

Cas de test de fonctionnalité

Les cas de test de fonctionnalité permettent de déterminer si l’interface d’une application fonctionne avec le rest du système et ses utilisateurs. Les tests identifient le succès ou l’échec des fonctions que le logiciel est censé exécuter. Les cas sont un type de test de boîte noire qui utilise pour base les spécifications ou les user stories du logiciel sous test. Cela permet d’effectuer les tests sans avoir à accéder au fonctionnement ou aux structures internes du logiciel testé. L’équipe QA est l’auteur habituel des cas de test de fonctionnalité, car ils relèvent des processus d’AQ normaux. Ils peuvent être écrits et exécutés dès que le développement rend une première fonction disponible pour le test. Pour aider au développement, ils peuvent être écrits avant le code, si tous les testeurs ont access aux exigences. Comme indiqué ci-dessus, ils peuvent être écrits et exécutés dès que cela est possible et ils doivent être répétés chaque fois que des mises à jour sont ajoutées, jusqu’au moment où les clients deviennent une possibilité.

Exemple: Confirmer qu’un utilisateur peut télécharger avec succès une photo de profil.

Cas de test d’interface utilisateur

Les scénarios de test de l’interface utilisateur permettent de vérifier que des éléments spécifiques de l’interface utilisateur graphique fonctionnent et fonctionnent comme prévu. Ces types de scénarios de test peuvent être utilisés pour identifier les incohérences cosmétiques, les erreurs de grammaire et d’orthographe, les liens et tout autre élément avec lequel l’utilisateur interagit ou voit. Ces cas sont généralement écrits par l’équipe de test, mais l’équipe de conception peut également être impliquée dans la mesure où elle connaît le mieux l’interface. Les cas de test d’interface utilisateur sont les types de cas de test dans les tests logiciels qui génèrent généralement des tests inter-navigateurs. Les navigateurs ont tendance à rendre les choses différemment et les scénarios de test de l’interface utilisateur garantissent que votre application se comporte de manière cohérente sur plusieurs navigateurs. Ces scénarios de test seront exécutés une fois la phase de développement terminée et l’interface utilisateur connectée à la firebase database.

Exemple: que se passe-t-il lorsque le site Web est affiché sur un petit écran tel qu’un téléphone portable? Est-ce que l’interface utilisateur est cassée?

Cas de test de performance

Les tests de performance valident les temps de réponse et l’efficacité globale d’une application. C’est-à-dire qu’après l’exécution d’une action, combien de temps faut-il pour que le système réponde? Les tests de performance doivent avoir un ensemble de critères de réussite très clair. L’équipe de test écrit généralement ces cas de test et ils sont souvent automatisés. Une grande application peut avoir des centaines ou des milliers de tests de performance. L’automatisation de ces tests et leur exécution fréquente aident à exposer les scénarios où l’application ne fonctionne pas au niveau attendu. Les tests de performance aident à comprendre comment l’application fonctionnera dans le monde réel. Ces cas peuvent être écrits une fois que l’équipe de test a des exigences de performance de l’équipe de produit. Cependant, de nombreux problèmes de performances peuvent être identifiés manuellement sans avoir à spécifier les exigences.

Exemple: combien de temps faut-il au système pour authentifier un utilisateur et charger la page suivante? Lorsque plusieurs personnes se connectent en même temps, l’application rest-t-elle stable?

Cas de test d’intégration

Les cas de test d’intégration ont pour but de déterminer comment les différents modules interagissent les uns avec les autres. L’objective principal des cas de test d’intégration est de s’assurer que les interfaces entre les différents modules fonctionnent correctement. L’équipe de test identifie les domaines devant faire l’object de tests d’intégration, tandis que l’équipe de développement fournira des informations sur la manière dont ces scénarios de test doivent être écrits. Chacune de ces deux équipes peut travailler pour écrire les cas. Ils vérifient que les modules qui fonctionnent déjà individuellement sont également capables de travailler ensemble.

Exemple: Vérification du lien entre la page d’accueil et la section «Favoris». Lorsque vous ajoutez un élément en tant que «favori», à partir de la page d’accueil, apparaît-il dans la section «Favoris»?

Cas de test d’utilisation

Les cas de test d’utilisabilité peuvent souvent être appelés «tâches» ou «scénarios». Plutôt que de fournir des instructions détaillées, étape par étape, pour exécuter le test, le testeur se voit proposer un scénario ou une tâche de haut niveau. Les cas de test d’utilisabilité permettent d’identifier comment un utilisateur s’approche naturellement et utilise l’application. Ils aident à guider le testeur dans diverses situations et stream. Aucune connaissance préalable de l’application n’est nécessaire. Ces scénarios de test sont généralement préparés par l’équipe de conception aux côtés de l’équipe de test. Les tests d’utilisabilité doivent être effectués avant les tests d’acceptation des utilisateurs.

Exemple: L’utilisateur peut-il append plusieurs articles à son panier? Comment est cette expérience?

Cas de test de firebase database

Les cas de test pour le test de firebase database examinent ce qui se passe en coulisse. L’interface utilisateur est propre et tout semble fonctionner… mais où vont toutes ces données? Pour écrire ces scénarios de test, vous devez avoir une compréhension approfondie de l’application entière, des tables de firebase database et des procédures stockées. L’équipe de test utilisera souvent des requêtes SQL pour développer des cas de test de firebase database. Les tests de firebase database sont utilisés pour vérifier que le développeur a écrit le code de manière à stocker et gérer les données de manière cohérente et sûre.

Exemple: considérons la création d’un profil utilisateur. Lorsque l’utilisateur soumet son profil, les éléments suivants doivent être testés en ce qui concerne la firebase database. L’application a-t-elle stocké les données saisies dans la firebase database? Des données ont-elles été perdues dans le processus? Les données partiellement exécutées n’auraient pas dû être enregistrées. Les utilisateurs non autorisés ne devraient pas pouvoir afficher ou accéder aux informations de l’utilisateur.

Cas de test de sécurité

Les tests de sécurité permettent de garantir que l’application restreint les actions et les permissions là où c’est nécessaire. Ces cas de test sont écrits pour protéger les données quand et où elles doivent être protégées. Les tests de sécurité servent à piloter les tests de pénétration et d’autres types de tests de sécurité. L’authentification et le cryptage sont souvent au centre des tests de sécurité. L’équipe de sécurité (s’il existe) est généralement responsable de la rédaction et de la réalisation de ces tests.

Exemple: Si un utilisateur atteint un nombre X de tentatives de connexion infructueuses, le compte devient-il bloqué? Un utilisateur peut-il télécharger des données sans être connecté?

Cas de test d’acceptation utilisateur

Les cas de test d’acceptation utilisateur, ou les cas de test «UAT», aident l’équipe à tester l’environnement de test d’acceptation utilisateur. Ces cas de test doivent être larges, couvrant tous les domaines de l’application. Le but de ces cas de test n’est pas de trouver des bogues (on espère qu’ils ont déjà été trouvés et corrigés dans les tests précédents), mais pour vérifier que l’application est acceptable pour l’utilisateur. Ainsi, lorsqu’ils exécutent un test, les résultats de ce test et l’expérience de ce test sont-ils acceptables? Étant donné que de nombreux autres types de tests ont déjà été effectués au moment où UAT a démarré, l’accent n’est plus mis sur le niveau de détail, mais sur l’ensemble. Les cas de test d’acceptation utilisateur sont utilisés par l’utilisateur final ou le client et préparés par l’équipe de test ou le chef de produit. C’est peut-être la phase la plus importante du test car c’est la dernière étape avant la mise en production.

Exemple: Si vous testez, par exemple, une application de gestion de photos pour un studio de photographie, le client (l’utilisateur) doit vérifier qu’il est capable de télécharger et de gérer ses photos de manière à répondre aux besoins de son entreprise.