Tests unitaires vs tests fonctionnels

Quelle est la différence entre les tests unitaires et les tests fonctionnels? Un test unitaire peut-il également tester une fonction?

Test unitaire - test d'une unité individuelle, telle qu'une méthode (fonction) dans une classe, avec toutes les dépendances simulées.

Test fonctionnel - Test d'intégration AKA, testant une tranche de fonctionnalité dans un système. Cela testera de nombreuses méthodes et peut interagir avec des dépendances telles que des bases de données ou des services Web.

Les tests unitaires indiquent à un développeur que le code fait bien les choses; les tests fonctionnels indiquent à un développeur que le code fait les bonnes choses .

Vous pouvez en savoir plus sur les tests unitaires et les tests fonctionnels

Une analogie bien expliquée dans la vie réelle des tests unitaires et des tests fonctionnels peut être décrite comme suit,

Plusieurs fois, le développement d'un système est assimilé à la construction d'une maison. Bien que cette analogie ne soit pas tout à fait correcte, nous pouvons l'étendre afin de comprendre la différence entre les tests unitaires et les tests fonctionnels.

Les tests unitaires sont analogues à un inspecteur en bâtiment visitant le chantier de construction d'une maison. Il se concentre sur les différents systèmes internes de la maison, la fondation, la charpente, l'électricité, la plomberie, etc. Il s'assure (teste) que les pièces de la maison fonctionneront correctement et en toute sécurité, c'est-à-dire qu'elles respectent le code du bâtiment.

Les tests fonctionnels dans ce scénario sont analogues à ceux du propriétaire qui visite ce même chantier de construction. Il suppose que les systèmes internes se comporteront de manière appropriée, que l'inspecteur en bâtiment accomplit sa tâche. Le propriétaire est concentré sur ce que ce sera de vivre dans cette maison. Il est préoccupé par l'apparence de la maison, les différentes pièces sont-elles de taille confortable, la maison répond-elle aux besoins de la famille, les fenêtres sont-elles un bon endroit pour profiter du soleil du matin.

Le propriétaire effectue des tests fonctionnels sur la maison. Il a le point de vue de l'utilisateur.

L'inspecteur en bâtiment effectue des tests unitaires sur la maison. Il a la perspective du constructeur.

En résumé,

Les tests unitaires sont écrits du point de vue des programmeurs . Ils sont faits pour s'assurer qu'une méthode particulière (ou une unité ) d'une classe effectue un ensemble de tâches spécifiques.

Les tests fonctionnels sont écrits du point de vue de l' utilisateur . Ils s'assurent que le système fonctionne comme les utilisateurs s'y attendent.

• Un test unitaire teste une unité de comportement indépendante . Qu'est-ce qu'une unité de comportement? Il s'agit de la plus petite pièce du système qui peut être testée indépendamment à l'unité. (Cette définition est en fait circulaire, OIEau il est vraiment pas une définition du tout , mais il semble fonctionner assez bien dans la pratique, parce que vous pouvez trier-de comprendre intuitivement.)

• Un test fonctionnel teste une fonctionnalité indépendante.

• Une unité de comportement est très petite: bien que je n'aime absolument pas ce stupide mantra "un test unitaire par méthode", du point de vue de la taille , il est à peu près juste. Une unité de comportement est quelque chose entre une partie d'une méthode et peut-être quelques méthodes. Au plus un objet, mais pas plus d'un.

• Un élément de fonctionnalité comprend généralement de nombreuses méthodes et coupe plusieurs objets et souvent plusieurs couches architecturales.

• Un test unitaire serait quelque chose comme: lorsque j'appelle la validate_country_code()fonction et que je lui passe le code pays, 'ZZ'elle doit retourner false.

• Un test fonctionnel serait: lorsque je remplis le formulaire d'expédition avec un code de pays de ZZ, je devrais être redirigé vers une page d'aide qui me permet de choisir mon code de pays dans un menu.

• Les tests unitaires sont écrits par les développeurs, pour les développeurs, du point de vue du développeur.

• Les tests fonctionnels peuvent être destinés aux utilisateurs, auquel cas ils sont écrits par les développeurs avec les utilisateurs (ou peut-être avec les bons outils et les bons utilisateurs même par les utilisateurs eux-mêmes), pour les utilisateurs, du point de vue de l'utilisateur. Ou ils peuvent être confrontés à des développeurs (par exemple, lorsqu'ils décrivent des fonctionnalités internes dont l'utilisateur ne se soucie pas), auquel cas ils sont écrits par des développeurs, pour des développeurs, mais toujours du point de vue de l'utilisateur.

• Dans le premier cas, les tests fonctionnels peuvent également servir de tests d'acceptation et d'encodage exécutable d'exigences fonctionnelles ou de spécification fonctionnelle, dans le second cas, ils peuvent également servir de tests d'intégration.

• Les tests unitaires changent fréquemment, les tests fonctionnels ne devraient jamais changer dans une version majeure.

TLDR:

Pour répondre à la question: Le test unitaire est un sous-type de test fonctionnel.

Il existe deux grands groupes: les tests fonctionnels et non fonctionnels . La meilleure illustration (non exhaustive) que j'ai trouvée est celle-ci (source: www.inflectra.com ):

(1) Test unitaire: test de petits extraits de code (fonctions / méthodes). Il peut être considéré comme un test fonctionnel (boîte blanche).

Lorsque les fonctions sont réunies, vous créez un module = une pièce autonome, éventuellement avec une interface utilisateur qui peut être testée (Test de module). Une fois que vous avez au moins deux modules séparés, vous les collez ensemble puis vient:

(2) Test d'intégration: lorsque vous assemblez deux ou plusieurs éléments de (sous) modules ou (sous) systèmes et voyez s'ils fonctionnent bien ensemble.

Ensuite, vous intégrez le 3e module, puis les 4e et 5e dans l'ordre que vous ou votre équipe jugerez bon, et une fois que toutes les pièces du puzzle sont placées ensemble, vient

(3) Test du système: tester SW dans son ensemble. Il s'agit à peu près de «tests d'intégration de toutes les pièces ensemble».

Si ça va, alors vient

(4) Test d'acceptation: avons-nous construit ce que le client a demandé? Bien sûr, les tests d'acceptation doivent être effectués tout au long du cycle de vie , pas seulement à la dernière étape, où vous réalisez que le client voulait une voiture de sport et que vous avez construit une camionnette.

"Test fonctionnel" ne signifie pas que vous testez une fonction (méthode) dans votre code. Cela signifie, en général, que vous testez la fonctionnalité du système - lorsque je lance foo file.txtsur la ligne de commande, les lignes file.txtsont peut-être inversées. En revanche, un seul test unitaire couvre généralement un seul cas d'une seule méthode - length("hello")devrait retourner 5, et length("hi")devrait retourner 2.

Voir également la position d' IBM sur la ligne entre les tests unitaires et les tests fonctionnels .

La distinction de base, cependant, est que les tests fonctionnels testent l'application de l'extérieur, du point de vue de l'utilisateur. Les tests unitaires testent l'application de l'intérieur, du point de vue du programmeur. Les tests fonctionnels devraient vous aider à créer une application avec les bonnes fonctionnalités et vous garantir de ne jamais la casser accidentellement. Les tests unitaires devraient vous aider à écrire du code propre et sans bogue.

Tiré du livre "Python TDD" de Harry Percival

Selon l'ISTQB, ces deux éléments ne sont pas comparables. Les tests fonctionnels ne sont pas des tests d'intégration.

Le test unitaire est un niveau de test et le test fonctionnel est un type de test.

Fondamentalement:

La fonction d'un système (ou d'un composant) est «ce qu'il fait». Ceci est généralement décrit dans une spécification d'exigences, une spécification fonctionnelle ou dans des cas d'utilisation.

tandis que

Les tests de composants, également appelés tests unitaires, de modules et de programmes, recherchent les défauts et vérifient le fonctionnement des logiciels (modules, programmes, objets, classes, etc.) qui peuvent être testés séparément.

Selon ISTQB, le composant / test unitaire peut être fonctionnel ou non fonctionnel:

Les tests de composants peuvent inclure des tests de fonctionnalité et des caractéristiques non fonctionnelles spécifiques telles que le comportement des ressources (par exemple des fuites de mémoire), des tests de performances ou de robustesse, ainsi que des tests structurels (par exemple la couverture de décision).

Citations des fondements des tests de logiciels - Certification ISTQB

Dans Rails, le dossier unitaire est destiné à contenir des tests pour vos modèles, le dossier fonctionnel est destiné à contenir des tests pour vos contrôleurs, et le dossier d'intégration est destiné à contenir des tests qui impliquent un nombre illimité de contrôleurs interagissant. Les appareils sont un moyen d'organiser les données de test; ils résident dans le dossier fixtures. Le fichier test_helper.rb contient la configuration par défaut pour vos tests. vous pouvez visiter cela .

La façon dont j'y pense est la suivante: un test unitaire établit que le code fait ce que vous vouliez faire (par exemple, vous vouliez ajouter les paramètres a et b, vous les ajoutez en fait et ne les soustrayez pas), les tests fonctionnels testent que tout le code fonctionne ensemble pour obtenir un résultat correct, de sorte que ce que vous vouliez que le code fasse en fait obtient le bon résultat dans le système.

AFAIK, les tests unitaires ne sont PAS des tests fonctionnels. Permettez-moi de vous expliquer avec un petit exemple. Vous souhaitez tester si la fonctionnalité de connexion d'une application Web de messagerie fonctionne ou non, comme le ferait un utilisateur. Pour cela, vos tests fonctionnels doivent être comme ça.

1- existing email, wrong password -> login page should show error "wrong password"!
2- non-existing email, any password -> login page should show error "no such email".
3- existing email, right password -> user should be taken to his inbox page.
4- no @symbol in email, right password -> login page should say "errors in form, please fix them!" 

Nos tests fonctionnels devraient-ils vérifier si nous pouvons nous connecter avec des entrées invalides? Par exemple. L'email n'a pas de symbole @, le nom d'utilisateur a plus d'un point (un seul point est autorisé), .com apparaît avant @ etc.? En général, non! Ce genre de test entre dans vos tests unitaires.

Vous pouvez vérifier si des entrées non valides sont rejetées dans les tests unitaires, comme indiqué dans les tests ci-dessous.

class LoginInputsValidator
  method validate_inputs_values(email, password)
    1-If email is not like [email protected], then throw error.
    2-If email contains abusive words, then throw error.
    3-If password is less than 10 chars, throw error.

Notez que le test fonctionnel 4 fait ce que fait le test unitaire 1. Parfois, les tests fonctionnels peuvent répéter certains (pas tous) des tests effectués par des tests unitaires, pour différentes raisons. Dans notre exemple, nous utilisons le test fonctionnel 4 pour vérifier si un message d'erreur particulier apparaît lors de la saisie d'une entrée non valide. Nous ne voulons pas tester si toutes les mauvaises entrées sont rejetées ou non. C'est le travail des tests unitaires.

TEST D'UNITÉ

Le test unitaire comprend le test de la plus petite unité de code qui sont généralement des fonctions ou des méthodes. Les tests unitaires sont principalement effectués par le développeur d'unité / méthode / fonction, car ils comprennent le cœur d'une fonction. Le principal objectif du développeur est de couvrir le code par des tests unitaires.

Il a une limitation que certaines fonctions ne peuvent pas être testées par des tests unitaires. Même après la réussite de tous les tests unitaires; il ne garantit pas le bon fonctionnement du produit. La même fonction peut être utilisée dans quelques parties du système alors que le test unitaire n'a été écrit que pour une seule utilisation.

TEST FONCTIONEL

Il s'agit d'un type de test Black Box où les tests seront effectués sur les aspects fonctionnels d'un produit sans regarder le code. Les tests fonctionnels sont principalement effectués par un testeur de logiciels dédié. Il comprendra des techniques positives, négatives et BVA utilisant des données non standardisées pour tester la fonctionnalité spécifiée du produit. La couverture des tests est effectuée de manière améliorée par des tests fonctionnels plutôt que par des tests unitaires. Il utilise l'interface graphique de l'application pour les tests, il est donc plus facile de déterminer de quoi exactement une partie spécifique de l'interface est responsable plutôt que de déterminer de quoi un code est responsable.

très simplement on peut dire:

• boîte noire: test d'interface utilisateur comme test fonctionnel
• boîte blanche: test de code comme test unitaire

en savoir plus ici .

Test unitaire : - Le test unitaire est particulièrement utilisé pour tester le produit composant par composant spécialement pendant le développement du produit. Les types d'outils Junit et Nunit vous aideront également à tester le produit selon l'unité. ** Plutôt que de résoudre les problèmes après l'intégration, il est toujours confortable de le résoudre tôt dans le développement.

Tests fonctionnels: - En ce qui concerne les tests, il existe deux principaux types de tests: 1. test fonctionnel 2. test non fonctionnel.

Le test non fonctionnel est un test où un testeur testera que le produit exécutera tous les attributs de qualité que le client ne mentionne pas, mais ces attributs de qualité devraient être là. Comme: -Performances, utilisabilité, sécurité, charge, stress, etc. mais dans le test fonctionnel : - Le client est déjà présent avec ses exigences et celles-ci sont correctement documentées, la tâche des testeurs consiste à vérifier que la fonctionnalité de l'application fonctionne conformément au système proposé ou non. À cette fin, le testeur doit tester la fonctionnalité implémentée avec le système proposé.

Les tests unitaires sont généralement effectués par les développeurs. L'objectif de faire de même est de s'assurer que leur code fonctionne correctement. La règle générale est de couvrir tous les chemins dans le code à l'aide de tests unitaires.

Test fonctionnel : c'est une bonne référence. Explication des tests fonctionnels