Affirmation de Golang

Il y a trois composants principaux dans le cycle de vie d'un développeur: écrire du code, le code de test, corriger le code, répéter. Bien qu'il s'agisse d'une simplification excessive, il illustre un concept que tous les développeurs rencontrent.

Dans cet article, nous nous concentrerons sur une seule entité du cycle de vie d'un développeur: test. Le code de test est une fonctionnalité très utile pour tout développeur. Il permet de trouver et de corriger les bogues avant de déployer du code en production. Bien qu'il existe de nombreuses façons et fonctionnalités pour implémenter les tests de code, cet article se concentrera sur le package GO Assert.

Début avec les tests

Avant de plonger dans la façon de travailler avec le package de témoignages, apprenons à commencer à démarrer avec les tests GO.

La première étape consiste à savoir ce que vous voulez tester. Cela pourrait être une fonction simple pour une collection de méthodes.

Prenons un exemple de programme simple qui multiplie son entrée par 10.

Commencez par créer un répertoire pour stocker votre code.

Test MKIDR

Naviguez dans le répertoire et créez un fichier go contenant votre programme. Pour plus de simplicité, nous appellerons ce fichier principal.aller

tests de CD
toucher la main.aller

Modifiez le fichier avec votre éditeur de texte et créez votre programme. Pour suivre ce tutoriel, vous pouvez ajouter le code comme indiqué ci-dessous:

package principal
importer (
"FMT"
)
funcMultiply (x int) (résultat int)
Résultat = x * 10
Résultat de retour

funcmain ()
fmt.Println ("Début avec les tests")

Dans l'exemple de programme, nous avons une fonction qui prend une entrée entière et renvoie l'entier multiplié par 10.

Enregistrez et fermez le fichier.

L'étape suivante consiste à créer un test pour le programme ci-dessus. Pour ce faire, nous devons créer un fichier dans le même répertoire avec le suffixe _test. Cela indique au module de test Go que ce fichier contient une suite de tests pour le programme dans le répertoire.

Puisque nous voulons créer un test pour le principal.Go Program, nous appellerons le fichier de test comme:

toucher main_test.aller

Dans le fichier de test, nous pouvons créer des instructions de test pour notre programme.

Étant donné que nous souhaitons utiliser le package Assert, nous devons importer les tests et le package Assert.

Vous pouvez inclure les importations comme:

emballer
importer (
"essai"
"Github.com / streperr / témoigner / affirmer "
)

Ensuite, créez une fonction de test pour tester le programme principal. Nous pouvons créer des instructions de test comme indiqué:

package principal
importer (
"essai"
"Github.com / streperr / témoigner / affirmer "
)
FunCTestMultiply (T * Test.T)
affirmer.Égal (t, multiplier (10), 100)

Dans le programme ci-dessus, nous créons une fonction de test qui prend un test.Objet T. Le cadre de test permet à la fonction d'écrire l'échec de l'emplacement approprié à condition que cet objet.

À l'intérieur de la fonction, nous utilisons le package Assert pour vérifier si la fonction renvoie un résultat égal aux paramètres fournis. Si la fonction multiplier prend l'entier 10 et renvoie une valeur égale à 100, alors il passe le test.

Enregistrez le fichier de test et exécutez le test à l'aide de la commande:

faire un test

La commande ci-dessus doit prendre le fichier de test et exécuter les tests configurés.

Un exemple de sortie est comme indiqué:

=== Exécutez TestMultiply
--- Passer: TestMultiply (0.00S)
PASSER
Ok Linuxhint / GO-ASSERT
> Test exécuté terminé au 1/31/2022, 13:38:17 <

Comme vous le remarquerez à partir de la sortie ci-dessus, la fonction passe le test.

Modifions la valeur de la fonction pour illustrer une instruction d'échec. Par exemple, modifiez le troisième paramètre de la fonction de test en une valeur incorrecte. Par exemple:

FunCTestMultiply (T * Test.T)
affirmer.Égal (t, multiplier (10), 10)

Dans cet exemple, nous disons au programme que si la fonction ne revient pas 10, alors la fonction échoue.

Remarque: Gardez à l'esprit que la fonction de test est incorrecte.

Si nous exécutons le test, nous devrions obtenir un échec comme:

=== Exécutez TestMultiply
affirmer \ main_test.Allez: 10:
Trace d'erreur:
Erreur: pas égal:
attendu: 100
réel: 10
Test: testmultiply
--- Échec: testMultiply (0.00S)
ÉCHOUER
Échec Linuxhint / Go-Assent 0.040
> Test exécuté terminé au 1/31/2022, 13:40:59 <

La sortie ci-dessus illustre un test raté.

Affirmation de Golang

Maintenant que nous avons les bases des tests à l'écart, passons à notre concentration vers le package Assert. Dans notre exemple précédent, nous avons utilisé la méthode égale pour vérifier si la fonction renvoie la valeur attendue. Cependant, le package Assert fournit une pléthore d'outils et de méthodes de test pour faciliter les tests de code.

Explorons quelques exemples supplémentaires pour illustrer la fonctionnalité du package ASSERT.

Golang Test Inequality

Nous pouvons utiliser le package Assert pour vérifier les inégalités en utilisant la méthode notequal (). La syntaxe de fonction est comme indiqué:

func notequal (t testt, attendu, interface réelle , msgandargs… interface ) bool

La fonction prend un t.Tester objet, la valeur attendue et réelle et un message d'impression. Il vérifie si la valeur attendue et réelle ne sont pas égales. Si c'est vrai, le test passe, sinon, échouer.

Un exemple est comme indiqué:

FunCTestNotequal (T * Test.T)
affirmer.Notequal (t, 100, 10, "Les valeurs ne doivent pas être égales")

Le code ci-dessus vérifie si les valeurs ne sont pas égales. Un exemple de sortie est comme indiqué:

=== Exécutez TestNotequal
--- Passer: testNotequal (0.00S)
PASSER
OK Linuxhint / Go-Assent 0.037

Code d'état HTTP Test de Golang

Nous pouvons utiliser la méthode httpStaturScode () pour vérifier si un gestionnaire renvoie le code d'état spécifié.

Supposons que nous ayons un serveur HTTP, que si nous faisons une demande pour renvoyer le code d'état de 200. Nous ne plongerons pas profondément dans la façon de créer un serveur HTTP dans Go. Consultez notre tutoriel sur le sujet pour en savoir plus.

Un exemple de serveur HTTP est comme indiqué:

package principal
importer (
"Io"
"net / http"
)
Var Mux Map [String] Func (HTTP.Réponsewriter, * http.Demande)
funcmain ()
serveur: = http.Serveur
Addr: ": 8080",
Handler: & MyHandler ,

MUX = Make (map [String] func (http.Réponsewriter, * http.Demande))
Mux ["/"] = Sayhello
serveur.ÉcouterAndServe ()

TypeMyHandlerstruct
func (* myHandler) servehttp (w http.Réponsewriter, r * http.Demande)
Si h, ok: = mux [r.URL.Chaîne()]; d'accord
h (w, r)
retour

Io.WriteString (W, "Server en cours d'exécution:" + R.URL.Chaîne())

funcsayhello (w http.Réponsewriter, r * http.Demande)
Io.WriteString (w, "Salut!")

Nous pouvons créer un test pour vérifier si la fonction HTTP Handler Renvoie le code d'état spécifié. Dans notre cas, la fonction HTTP Handler est la méthode Sayhello. La fonction de test est comme indiqué:

Func TestStaturScode (T * Test.T)
affirmer.Httpstaturuscode (t, sayhello, "get", "/", nil, 200)

Dans l'exemple ci-dessus, nous créons une fonction de test pour vérifier l'envoi d'une demande GET au serveur avec la fonction HTTP Handler Sayhello, renvoie le code d'état de 200.

Le code renvoie:

=== Exécuter TestStaturSCODE
--- Passer: TestStaturuscode (0.00S)
PASSER
OK Linuxhint / Go-Assent 0.034
> Test exécuté terminé au 1/31/2022, 14:44:39 <

Panique de test de Golang

Un autre test que nous pouvons exécuter est de vérifier si une fonction spécifique panique. Nous pouvons utiliser l'affirmation.Méthode Panicks () comme indiqué:

FunCTestPanic (T * Test.T)
affirmer.Panics (t, func ()
panique ("Je panique définitivement!")
, "Devrait paniquer")

Dans l'exemple ci-dessus, nous vérifions si la fonction si elle panique.

Golang vérifie si le répertoire existe

Si vous souhaitez tester si un répertoire spécifique existe dans un chemin spécifié, vous pouvez utiliser la méthode Direxists ().

Par exemple:

FunCTestDir (T * Test.T)
affirmer.Direxistes (t, "… / Assert")

Conclusion

C'était un guide complet sur la façon de commencer avec les tests dans le langage de programmation Go. Les tests sont fortement utilisés dans les projets multi-développeurs. Par conséquent, apprendre à effectuer des tests est exceptionnel.

Il y a beaucoup plus de fournitures par le package Assert que celles indiquées dans ce tutoriel. La documentation élargit ce.

https: // pkg.aller.dev / github.com / streperr / témoigner / affirmer