Content de te revoir.
Écrivons maintenant notre premier test, nous allons simplement exécuter une fonction simple et ce programme créera
dans notre fichier DCPI principal, disons, agrandissons un peu cela.
Nous dirons que nous avons une fonction appelée do stuff.
Oui, fonction très descriptive.
Maintenant, ici, nous dirons simplement que nous acceptons un nombre.
Et nous renverrons simplement NUM plus cinq, une fonction très, très simple.
Disons donc que c'est notre code qui construit notre application, donc ce n'est qu'une fonction, mais hypothétiquement, nous avons
de nombreuses fonctions que nous voulons tester car ce sont des actions que nous allons effectuer dans notre
code.
Ainsi fonctionne le test unitaire.
Est comme ça.
Nous avons notre fichier de test, et après avoir importé nos tests unitaires, nous voulons importer tandis que le fichier que
nous voulons tester dans notre cas, c'est le DCPI principal, alors importons simplement le fichier main.
Qui est juste ici.
Ou nous pouvons simplement importer la fonction si nous le voulons.
Mais dans notre cas, hypothétiquement, nous avons de nombreuses fonctions ici, nous pouvons donc simplement importer, signifier et utiliser
toutes les fonctions disponibles là-bas.
Maintenant, la façon dont le test unitaire fonctionne est que nous créons une classe et que nous la nommons comme vous le souhaitez ici, elle contiendra
tous nos tests.
Appelons-le simplement test principal.
Et nous héritons à l'intérieur de cette classe de ce que le test unitaire nous donne, qui est un test.
C'est donc juste une façon standard de travailler avec les tests unitaires, donc nous héritons de n'importe quel cas
de test unitaire et maintenant nous avons cette fonctionnalité disponible dans notre classe principale de test.
Maintenant, ici, nous pouvons commencer à tester et à écrire du code à tester.
Alors, comment pouvons-nous tester principal?
Faire des trucs fonction.
Eh bien, nous disons simplement, hé, écrivons une fonction ici ou une méthode, car cela fait partie
d'une classe et disons, hé, je veux tester des choses.
Et ici, il recevra lui-même.
Maintenant, ici, je peux tester mon manteau afin que je puisse dire si non ici est égal à 10, je lui donne
juste un nombre aléatoire, alors je vais dire que le résultat sera égal au point principal.
Alors rappelez-vous, do stuff vient du Maine, qui est la fonction que nous voulons tester,
donc je veux exécuter la fonction do stuff et ici donner le numéro de paramètre, que je viens de donner ici, ou
appelons simplement ce test préparation.
Donc ce programme de test, nous allons exécuter le code et nous allons obtenir un résultat.
Et cette dernière ligne est la partie clé du test unitaire, le test unitaire nous permet de dire self dot, assert equal et assert equal
est quelque chose que nous obtenons lorsque nous héritons du test unitaire et assert equal dit, hé,
assert.
Ou assurez-vous que ces deux paramètres sont égaux dans notre cas, je veux tester que le résultat est égal à,
eh bien, dans notre cas, 10.
Plus cinq doit être égal à 15.
Très bien, maintenant, enfin ici, nous venons de lancer le test unitaire.
Et la façon dont nous gérons l'unité, parce que ce n'est qu'un test que j'ai fait, j'aurais pu faire plusieurs
tests.
Tout ce que nous avons à dire, c'est le test unitaire, point principal.
Qui exécutera l'intégralité du fichier de test dans le test effectué.
Maintenant, si je lance ceci maintenant, tout ce que j'ai à faire est de dire Python trois, ma ligne de commande et de dire test dot.
Et je reçois d'accord, j'ai effectué un test très rapidement en zéro seconde, c'était agréable et rapide.
Maintenant, disons que je fais autre chose où j'affirme égal que cela est égal à 10 si je lance ceci.
J'ai un échec, qu'est-ce qui a échoué ?
Eh bien, le test de fonction a échoué.
En ligne huit.
C'est donc ici que nous avons une assertion er nous en avons 15, mais nous nous attendions à 10.
À quel point cela est cool?
J'ai donc maintenant un échec, je dois donc corriger mon code.
Donc quelque chose ne va pas ici.
Maintenant, dans mon cas, c'est parce que j'ai affirmé.
La réponse est 15, mais que se passe-t-il si nous créons un autre test ici ?
Et vérifiez, hé, et si nous avions aussi des trucs à tester, et cette fois, le programme de test va être en fait un
morceau de ficelle.
Alors, que voulons-nous que la fonction fasse ?
Eh bien, dans notre cas, peut-être que cela nous donne une euh peut-être une valeur euh donc je vais juste dire une valeur.
Parce que cela ne devrait pas fonctionner si je l'exécute maintenant, soyons clairs, si je l'exécute maintenant.
D'accord, je dois tester.
Mais j'ai une oreille et je vois ici que je reçois une oreille disant que, hé, je reçois un taip
ne peut que concaténer une chaîne, pas huit.
Maintenant, dans ce cas, qu'est-ce qui échoue réellement ?
Est le fichier de test, car ce que nous venons de faire échoue en fait à notre fonction.
Mais tout de suite, je vois que très bien, eh bien, c'est quelque chose que nous devons corriger pour que
je puisse retourner dans le Maine et dire, hé, je veux m'assurer que nous attrapons toutes les erreurs.
Comme les poires thaïlandaises ou les évaluateurs, la première chose que je peux faire est simplement de dire et.
Non.
Et si je dis cela pour m'assurer que nous convertissons quelque chose en un entier et je lance ceci.
En ce moment, j'obtiens une valeur aérienne et une valeur littérale afin qu'elle puisse être exécutée sur ce morceau de ficelle.
OK, donc une autre chose que nous pouvons faire pour améliorer notre code est de l'envelopper dans un bloc tri except.
À droite.
Et puis nous pouvons attraper.
Alors disons sauf.
Et ici, acceptez une erreur de valeur et disons que l'air et ici nous pouvons faire ce que nous voulons.
Donc, nous pouvons retourner si nous voulons de l'air ou nous pouvons même augmenter l'air dans notre cas, renvoyons simplement l'air.
Et je vais vous montrer pourquoi dans une seconde.
Maintenant, si j'ai couru ça.
Vous voyez que mon test échoue, mais maintenant c'est en fait une assertion, euh l'assertion er vient
de notre fichier de test ici et j'affirme que je veux m'assurer que le résultat et la valeur er
sont égaux.
Maintenant, vous voyez ici qu'il y a un peu de décalage, nous avons une erreur de valeur ici qui n'égale pas l'erreur
de valeur de classe.
Maintenant, c'est un peu un truc où parce que nous retournons un air.
C'est en fait une instance de la classe value er.
Nous devons donc faire quelque chose comme ça, nous devons dire, hé, c'est par exemple.
Et disons, qu'est-ce que c'est, un cas de guerre est un résultat, un cas de valeur euh comme celui-ci, mais le problème
ici.
Est-ce que cela agrandit un peu les choses, le problème ici est que assert equals va s'attendre à
deux paramètres, deux choses qui doivent être égales.
Mais ici, je veux juste m'assurer que cela renvoie vrai, que le résultat est une instance d'erreur de valeur.
Alors comment puis-je faire cela?
Eh bien, en plus d'affirmer égal, nous avons quelques autres méthodes que le test unitaire nous donne.
Si je vais à la documentation des tests unitaires ici sur la première ligne, la liste des méthodes de recherche est indiquée.
Donc ici, je vois que ce sont toutes les méthodes pour affirmer et tester notre code.
Celui que nous voulons probablement est celui-ci Asatru.
Pour vérifier si quelque chose est vrai.
Donc si j'affirme.
Que c'est vrai.
Et j'ai exécuté mon test, clarifions cela et exécutons à nouveau mon test.
Voilà, j'ai fait deux tests et tout semble ok, et encore une fois, pour revoir ça, pourquoi ça ?
Eh bien, je fais mon test pendant.
Et puis je vais lancer le test, faire des trucs qui vont être OK, puis je fais la deuxième partie où le paramètre de test est quelque chose
que nous ne voulons pas vraiment, qui est juste un morceau de ficelle.
Le résultat va nous donner une erreur de valeur car nous avons détecté cette erreur et nous retournons maintenant
l'erreur.
Et puis enfin, nous exécutons ce morceau de code, hé, est-ce vrai, le résultat va-t-il être une erreur de valeur
?
Donc, vous voyez ce que nous faisons ici, ce que nous essayons de faire avec nos tests est d'améliorer notre fonction en
essayant simplement de la casser.
Donc nous voulons casser notre fonction et dire, hé, puis-je tromper cette fonction pour qu'elle me donne un héritier ?
Et puis une fois que vous faites cela et qu'un test échoue, vous revenez à une fonction et essayez de la réparer, un peu comme
nous l'avons fait ici, ce qui est vraiment, vraiment cool.
C'est une pratique courante avec les tests où vous essayez de casser des choses jusqu'à ce que, eh bien, la fonction devienne
parfaite.
Maintenant, je veux que vous preniez votre temps ici et voyez si nous pouvons casser cette fonction et peut-être ajouter quelques
tests supplémentaires dans la prochaine vidéo, je vais en ajouter quelques autres pour rendre cette fonction encore meilleure.
Je te verrai dans le prochain.