Comment tester les fonctions Golang pour garantir leur fiabilité ?

Les tests de fiabilité des fonctions Golang impliquent des tests unitaires, en utilisant le package de tests pour tester une seule fonction de manière isolée ; des tests pilotés par des tables, en utilisant des tables de test pour tester plusieurs entrées, en créant des sous-tests dans une seule fonction de test, en utilisant des outils ; telles que les bibliothèques github comme .com/ory/dockertest testent le comportement d'intégration de votre code.

Comment tester les fonctions Golang pour garantir leur fiabilité

L'écriture de fonctions fiables dans Golang est cruciale pour créer des applications robustes et stables. Des tests sont nécessaires pour garantir que les fonctions se comportent comme prévu. Cet article présentera comment tester les fonctions Golang et fournira un cas pratique.

Tests unitaires

Les tests unitaires sont une technique permettant de tester une seule fonction ou un seul module de manière isolée. Dans Golang, utilisez le package testing pour les tests unitaires : testing 包进行单元测试：

package mypkg

import "testing"

func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {3, 4, 7},
    }

    for _, tt := range tests {
        actual := Add(tt.a, tt.b)
        if actual != tt.expected {
            t.Errorf("Add(%d, %d) = %d, expected %d", tt.a, tt.b, actual, tt.expected)
        }
    }
}

表驱动的测试

表驱动的测试允许我们在使用相同测试函数的同时测试多个输入。这意味着我们可以为每个测试用例创建单独的测试表：

func TestAddTableDriven(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {3, 4, 7},
    }

    for _, tt := range tests {
        t.Run(fmt.Sprintf("TestAdd(%d, %d)", tt.a, tt.b), func(t *testing.T) {
            actual := Add(tt.a, tt.b)
            if actual != tt.expected {
                t.Errorf("Add(%d, %d) = %d, expected %d", tt.a, tt.b, actual, tt.expected)
            }
        })
    }
}

子测试

子测试允许在单个测试函数中创建多个子测试。这有助于组织测试并提供更多详细的错误消息：

func TestError(t *testing.T) {
    t.Run("case 1", func(t *testing.T) {
        err := Error(0)
        if err != nil {
            t.Errorf("Error(0) = %v", err)
        }
    })

    t.Run("case 2", func(t *testing.T) {
        err := Error(1)
        if err == nil {
            t.Error("Expected error for Error(1)")
        }
    })
}

集成测试

集成测试测试代码的集成行为，包括涉及多个函数的交互。在 Golang 中，可以使用 github.com/ory/dockertest

package mypkg_test

import (
    "context"
    "fmt"
    "io"
    "testing"

    "github.com/ory/dockertest"
)

func TestIntegration(t *testing.T) {
    // 创建一个容器，在其中运行我们的代码
    container, err := dockertest.NewContainer("my-org/my-image", "latest", nil)
    if err != nil {
        t.Fatal(err)
    }

    // 在容器中执行我们的代码
    output, err := container.Run(context.Background())
    if err != nil {
        t.Fatal(err)
    }

    // 检查输出以验证行为
    if _, err := io.WriteString(output, "Hello World\n"); err != nil {
        t.Fatal(err)
    }
    fmt.Fprintln(output, "Done")

    // 等待容器退出
    if err := container.Wait(); err != nil {
        t.Fatal(err)
    }
}

🎜Tests pilotés par table🎜🎜🎜Les tests pilotés par table nous permettent de tester plusieurs entrées simultanément tout en utilisant la même fonction de test. Cela signifie que nous pouvons créer des tables de test distinctes pour chaque cas de test : 🎜rrreee🎜🎜Subtests🎜🎜🎜Les sous-tests permettent la création de plusieurs sous-tests au sein d'une seule fonction de test. Cela permet d'organiser vos tests et de fournir des messages d'erreur plus détaillés : 🎜rrreee🎜🎜Tests d'intégration🎜🎜🎜Les tests d'intégration testent le comportement intégré de votre code, y compris les interactions impliquant plusieurs fonctions. Dans Golang, vous pouvez utiliser des bibliothèques telles que github.com/ory/dockertest pour les tests d'intégration : 🎜rrreee

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!