Comment intégrer des bibliothèques tierces dans les tests unitaires Golang ?

L'intégration de bibliothèques tierces dans les tests unitaires Golang peut être réalisée via l'injection de dépendances ou à l'aide de stubs : Injection de dépendances : utilisez des simulations ou des stubs au lieu d'implémentations réelles de bibliothèques. Exemple : utilisez MockDependency pour simuler une bibliothèque tierce et l'injecter dans la fonction testée. Stub : donne accès à la véritable implémentation de la bibliothèque. Exemple : utilisez stubFunc pour remplacer une fonction réelle dans une bibliothèque tierce et remplacer son comportement.

Comment intégrer des bibliothèques tierces dans les tests unitaires Golang

L'intégration de bibliothèques tierces dans les tests unitaires Golang nécessite certaines compétences. Cet article vous guidera sur la façon d’accomplir cette tâche et fournira un exemple pratique de la façon d’y parvenir.

1. Utiliser l'injection de dépendances

L'injection de dépendances est un moyen efficace d'isoler les bibliothèques tierces dans les tests. Il vous permet de fournir des simulations ou des stubs dans vos tests au lieu d'utiliser l'implémentation réelle de la bibliothèque.

import (
    "testing"

    "github.com/stretchr/testify/assert"
)

// MockDependency 模拟第三方库
type MockDependency struct {
    result int
}

// Method 模拟第三方库的方法
func (m *MockDependency) Method() int {
    return m.result
}

func TestFunctionUnderTest(t *testing.T) {
    // 使用模拟的依赖项
    dependency := &MockDependency{result: 42}

    // 调用待测函数
    result := FunctionUnderTest(dependency)

    // 断言结果
    assert.Equal(t, 42, result)
}

2. Utiliser des stubs

Les stubs sont un autre moyen d'isoler les bibliothèques tierces. Contrairement aux simulations, les stubs donnent accès à la véritable implémentation de la bibliothèque mais vous permettent de contrôler ses appels en interceptant ou en modifiant son comportement.

import (
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/google/go-cmp/cmp"
)

func TestFunctionUnderTest(t *testing.T) {
    // 使用存根函数
    stubFunc := func() (string, error) {
        return "stubbed result", nil
    }
    originalFunc := library.Func

    // 覆盖实际函数
    library.Func = stubFunc

    // 调用待测函数
    result, err := FunctionUnderTest()

    // 还原实际函数
    library.Func = originalFunc

    // 断言结果
    assert.NoError(t, err)
    diff := cmp.Diff("stubbed result", result)
    assert.Empty(t, diff)
}

Cas pratique

Supposons que nous ayons une fonction NewService，它从第三方库 github.com/example/service pour obtenir une instance de service. Nous pouvons utiliser l'injection de dépendances pour tester cette fonction :

import (
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/example/service"
)

// MockService 模拟 service 库
type MockService struct {
    result *service.Service
}

// NewMockService 返回一个模拟的服务实例
func NewMockService(result *service.Service) *MockService {
    return &MockService{result: result}
}

// Service 返回模拟的服务实例
func (m *MockService) Service() *service.Service {
    return m.result
}

func TestNewService(t *testing.T) {
    // 使用模拟的服务
    mockService := NewMockService(&service.Service{})

    // 调用待测函数
    newService, err := NewService(mockService)

    // 断言结果
    assert.NoError(t, err)
    assert.Equal(t, &service.Service{}, newService)
}

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!