Wie verspotte ich Funktionen in Golang-Unit-Tests?

Es gibt die folgenden Möglichkeiten, Funktionen beim Golang-Unit-Testen zu verspotten: Verwenden Sie das Mock-Paket: Verwenden Sie die Methode gomock.Mock, um eine Mock-Funktion zu erstellen, und verwenden Sie EXPECT und RETURN, um deren Rückgabewert und Verhalten festzulegen. Verwendung von „testing.T“: Verwenden Sie die Methoden „Helper“, „Run“ und „Parallel“ in der Struktur „testing.T“, um Funktionen zu simulieren. Verwenden Sie anonyme Funktionen: Verwenden Sie anonyme Funktionen, um Funktionen schnell zu simulieren, insbesondere wenn sie nur einmal aufgerufen werden müssen.

Wie verspottet man Funktionen in Golang-Unit-Tests?

Bei Unit-Tests ist das Verspotten von Funktionen eine leistungsstarke Technik zum Ersetzen tatsächlicher Funktionen beim Testen Ihres Codes. Damit können Sie die Richtigkeit einer Funktion überprüfen, ohne sich auf externe Faktoren verlassen zu müssen. Golang bietet verschiedene Möglichkeiten zur Simulation von Funktionen. In diesem Artikel werden einige der gängigsten Techniken vorgestellt.

Verwenden Sie das Paket 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

Das Paket mock ist die empfohlene Methode zum Simulieren von Funktionen. Es bietet eine einfache Schnittstelle, mit der Sie Modelle von Funktionsaufrufen erstellen und überprüfen können.

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())
}

Verwenden Sie testing.T

Die testing.T-Struktur bietet einige Methoden zum Simulieren von Funktionen, einschließlich Helper, Run- und <code>Parallel-Methoden.

package main

import (
    "fmt"
)

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

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

Anonyme Funktionen verwenden

Anonyme Funktionen sind eine schnelle Möglichkeit, eine Funktion zu simulieren, insbesondere wenn Sie nur einen einzigen Aufruf ausführen müssen. 🎜

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)
    }
}

🎜Praktischer Fall🎜🎜Das Folgende ist ein praktischer Fall der Verwendung eines Scheinpakets zur Simulation von Funktionen im Unit-Test:🎜rrreee

Das obige ist der detaillierte Inhalt vonWie verspotte ich Funktionen in Golang-Unit-Tests?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!