Expérience pratique dans le développement piloté par les tests à Golang

Expérience pratique du développement piloté par les tests à Golang

Aperçu :
Le développement piloté par les tests (TDD) est une méthode de développement logiciel courante. Il met l'accent sur l'écriture de code de test qui vérifie la fonctionnalité avant d'écrire le code réel. En écrivant du code de test, les développeurs peuvent mieux comprendre les exigences, définir avec précision les interfaces et améliorer la qualité et la maintenabilité du code. Cet article prendra le langage Golang comme exemple pour présenter comment utiliser le développement TDD dans des projets réels.

1. Paramètres d'environnement et gestion des dépendances
   Tout d'abord, avant de démarrer TDD, vous devez préparer l'environnement de développement Golang. Assurez-vous que Golang est installé et que les variables d'environnement GOROOT et GOPATH sont définies.

Dans Golang, il existe de nombreux outils de gestion des dépendances parmi lesquels choisir. Les plus courants incluent go mod, dep, etc. En prenant go mod comme exemple, utilisez la commande suivante pour initialiser le projet :

go mod init <项目名>

2. Créer des fichiers de test
   Pour exécuter TDD, chaque fonction doit avoir un code de test correspondant. Dans Golang, le fichier de test est suffixé par _test.go et Test est ajouté avant le nom de la fonction. _test.go为后缀，并且在函数名前加上Test。

以一个简单的计算器为例，我们可以创建一个calculator_test.go的文件，并编写测试代码：

package main

import (
    "testing"
)

func TestAdd(t *testing.T) {
    c := add(2, 3)
    if c != 5 {
        t.Error("Expected 5, got ", c)
    }
}

func TestSubtract(t *testing.T) {
    c := subtract(5, 2)
    if c != 3 {
        t.Error("Expected 3, got ", c)
    }
}

3. 编写功能代码
   测试代码编写完成后，我们需要编写功能代码来满足测试的需求。在本例中，我们可以在calculator.go文件中编写功能代码：

package main

func add(a, b int) int {
    return a + b
}

func subtract(a, b int) int {
    return a - b
}

4. 运行测试
   测试代码和功能代码编写完成后，我们可以运行测试代码来验证功能的正确性。在项目根目录下，运行以下命令：

go test

如果输出结果中没有出现错误，那么说明测试通过。

5. 迭代开发
   TDD的核心思想是迭代开发。在已经通过的测试代码基础上，我们可以添加更多的测试来覆盖更多的场景。然后，根据这些测试来修改和完善功能代码。

例如，我们可以添加一个测试来测试乘法运算：

func TestMultiply(t *testing.T) {
    c := multiply(4, 3)
    if c != 12 {
        t.Error("Expected 12, got ", c)
    }
}

然后，在功能代码中添加乘法函数：

func multiply(a, b int) int {
    return a * b
}

再次运行go test

En prenant comme exemple une simple calculatrice, on peut créer un fichier calculator_test.go et écrire le code du test :

6. func TestDivideByZero(t *testing.T) {
       defer func() {
           if r := recover(); r != nil {
               if r != "divide by zero" {
                   t.Error("Expected 'divide by zero' error")
               }
           } else {
               t.Error("Expected 'divide by zero' error")
           }
       }()
       divide(5, 0)
   }

   
   Écrire le code fonctionnelTest Après le le code est écrit, nous devons écrire du code fonctionnel pour répondre aux besoins des tests. Dans ce cas, nous pouvons écrire le code de la fonction dans le fichier calculator.go :

   func divide(a, b int) int {
       if b == 0 {
           panic("divide by zero")
       }
       return a / b
   }

   Exécuter le test

   Une fois le code de test et le code de fonction écrits, nous pouvons exécuter du code de test pour vérifier la fonctionnalité. Dans le répertoire racine du projet, exécutez la commande suivante :

   rrreee

   S'il n'y a aucune erreur dans la sortie, le test réussit.
   
   Développement itératifL'idée centrale de TDD est le développement itératif. Sur la base du code de test déjà réussi, nous pouvons ajouter plus de tests pour couvrir plus de scénarios. Ensuite, modifiez et améliorez le code fonctionnel en fonction de ces tests.

   Par exemple, on peut ajouter un test pour tester l'opération de multiplication :

   rrreee🎜Ensuite, ajouter la fonction de multiplication dans le code de la fonction : 🎜rrreee🎜Exécuter à nouveau la commande go test, si le le test réussit, cela signifie que notre développement itératif est sur le point. 🎜🎜🎜Gestion des situations anormales🎜Dans le développement réel, nous devons prendre en compte diverses situations anormales et écrire les codes de test correspondants. 🎜🎜🎜Par exemple, dans la calculatrice, il faut considérer le cas où le diviseur est 0. Nous pouvons ajouter un test comme celui-ci : 🎜rrreee🎜 Ensuite, ajoutez la fonction de division dans le code de la fonction : 🎜rrreee🎜Exécutez le test et nous obtiendrons un résultat de test réussi. 🎜🎜Résumé : 🎜Grâce au développement TDD, nous pouvons améliorer la qualité et la maintenabilité du code. Dans Golang, en écrivant du code de test, nous pouvons mieux comprendre les exigences, définir avec précision l'interface et garantir l'exactitude du code. 🎜🎜Bien que TDD augmente le temps de développement et la charge de travail, il peut réduire le temps de débogage et de maintenance ultérieur, améliorer l'efficacité du développement et la qualité du code. Par conséquent, TDD revêt une grande importance dans les projets réels, en particulier les projets impliquant une logique complexe et des changements fréquents d'exigences. 🎜🎜Grâce à l'introduction de cet article, j'espère que les lecteurs pourront mieux comprendre et appliquer l'expérience pratique du développement piloté par les tests dans Golang. Créons ensemble du code de haute qualité ! 🎜

   Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!