Comment simuler des fonctions dans les tests unitaires Golang ?

Il existe les manières suivantes de simuler des fonctions dans les tests unitaires Golang : Utilisez le package simulé : utilisez la méthode gomock.Mock pour créer une fonction simulée et utilisez EXPECT et RETURN pour définir sa valeur de retour et son comportement. Utilisation de testing.T : utilisez les méthodes Helper, Run et Parallel dans la structure testing.T pour simuler des fonctions. Utiliser des fonctions anonymes : utilisez des fonctions anonymes pour simuler rapidement des fonctions, en particulier lorsqu'elles ne doivent être appelées qu'une seule fois.

Comment simuler des fonctions dans les tests unitaires Golang ?

Dans les tests unitaires, les fonctions moqueuses sont une technique puissante pour remplacer les fonctions réelles lors du test de votre code. Il vous permet de vérifier l'exactitude d'une fonction sans vous fier à des facteurs externes. Golang propose diverses façons de simuler des fonctions, et cet article présentera certaines des techniques les plus courantes.

Utilisez le package mock mock 包

mock 包是模拟函数的推荐方式。它提供了一个简单的接口，允许您创建和验证函数调用的模拟。

package main

import (
    "fmt"

    "github.com/golang/mock/gomock"
)

type Fooer interface {
    Foo() string
}

func main() {
    ctrl := gomock.NewController(nil)
    defer ctrl.Finish()

    mockFooer := mock_Fooer(ctrl)

    // 设置模拟的返回值
    mockFooer.EXPECT().Foo().Return("Hello, world!")

    // 调用模拟函数
    fmt.Println(mockFooer.Foo())
}

使用 testing.T

testing.T 结构提供了一些用于模拟函数的方法，包括 Helper、Run 和 Parallel

Le package mock est la méthode recommandée pour simuler des fonctions. Il fournit une interface simple qui vous permet de créer et de vérifier des simulations d'appels de fonction.

package main

import (
    "fmt"
    "testing"
)

type Fooer interface {
    Foo() string
}

func TestFoo(t *testing.T) {
    t.Helper()

    // 设置模拟的返回值
    foo := func() string { return "Hello, world!" }

    // 调用模拟函数
    fmt.Println(foo())
}

Utilisez testing.T

La structure testing.T fournit certaines méthodes pour simuler des fonctions, notamment Helper, Run et <code>Parallèle.

package main

import (
    "fmt"
)

func main() {
    // 定义模拟函数
    foo := func() string { return "Hello, world!" }

    // 调用模拟函数
    fmt.Println(foo())
}

Utiliser des fonctions anonymes

Les fonctions anonymes sont un moyen rapide de simuler une fonction, en particulier lorsque vous n'avez besoin d'effectuer qu'un seul appel. 🎜

package main

import (
    "context"
    "fmt"
    "testing"

    "github.com/golang/mock/gomock"
)

type UserStore interface {
    Get(ctx context.Context, id int) (*User, error)
}

type User struct {
    Name string
}

func TestGetUser(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()

    mockUserStore := mock_UserStore(ctrl)

    // 设置模拟的返回值
    mockUserStore.EXPECT().Get(gomock.Any(), 1).Return(&User{Name: "John Doe"}, nil)

    // 实例化待测函数
    userService := UserService{
        userStore: mockUserStore,
    }

    // 调用待测函数
    user, err := userService.GetUser(context.Background(), 1)
    if err != nil {
        t.Fatalf("GetUser() failed: %v", err)
    }

    // 验证函数的行为
    if user.Name != "John Doe" {
        t.Errorf("GetUser() returned unexpected user name: %s", user.Name)
    }
}

🎜Cas pratique🎜🎜Ce qui suit est un cas pratique d'utilisation d'un package simulé pour simuler des fonctions dans des tests unitaires :🎜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!