Petua pemfaktoran semula untuk ujian unit fungsi Go

Untuk meningkatkan kebolehselenggaraan dan kebolehbacaan ujian unit fungsi Go, kami boleh: Mengeluarkan fungsi penegasan untuk memudahkan kod. Gunakan ujian dipacu jadual untuk menyusun data ujian. Tulis antara muka mengejek untuk menguji interaksi antara fungsi dan komponen. Jalankan ujian terperinci untuk mengasingkan dan menyahpepijat isu. Gunakan alat liputan untuk memastikan kelengkapan ujian dan panduan penambahbaikan.

Petua Pemfaktoran Semula untuk Ujian Unit Fungsi Go

Apabila kami mempunyai projek Go yang besar dan kompleks, penyelenggaraan dan kebolehbacaan ujian unit berfungsi boleh menjadi satu cabaran besar. Untuk menangani cabaran ini, kami boleh melaksanakan beberapa teknik pemfaktoran semula untuk meningkatkan kebolehselenggaraan dan kebolehbacaan ujian kami.

1. Ekstrak fungsi penegasan

Jika kod ujian mengandungi banyak penegasan yang sama, anda boleh mengekstrak fungsi penegasan untuk memudahkan kod. Sebagai contoh, kita boleh mentakrifkan fungsi AssertEqual untuk menyemak sama ada dua nilai adalah sama: AssertEqual 函数来检查两个值是否相等：

import "testing"

func AssertEqual(t *testing.T, expected, actual interface{}) {
    if expected != actual {
        t.Errorf("Expected %v, got %v", expected, actual)
    }
}

2. 使用表驱动的测试

表驱动的测试可以帮助组织和简化测试数据。它允许我们使用一个表来提供不同的输入和期望输出，然后对每个输入执行测试。例如，我们可以编写一个表驱动的测试来检查 Max 函数：

import (
    "testing"

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

func TestMax(t *testing.T) {
    tests := []struct {
        name    string
        input   []int
        expected int
    }{
        {"Empty slice", []int{}, 0},
        {"Single element", []int{1}, 1},
        {"Multiple elements", []int{1, 2, 3}, 3},
    }

    for _, tt := range tests {
        actual := Max(tt.input)
        assert.Equal(t, tt.expected, actual)
    }
}

3. 编写 mocking 接口

mocking 接口允许我们测试函数在与其他组件交互时的行为。我们可以使用一个 mocking 框架（如 mockery）来生成 mock 对象，该对象实现了我们关心的接口，但我们可以控制其行为。例如，我们可以编写一个 mockDatabase 来测试一个使用数据库的函数：

package main

import (
    "database/sql"
    "fmt"
    "time"

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

// MockDatabase is a mock database for testing purposes.
type MockDatabase struct {
    mock.Mock
}

// Query implements the Query method of a mock database.
func (m *MockDatabase) Query(query string, args ...interface{}) (*sql.Rows, error) {
    ret := m.Called(query, args)
    return ret.Get(0).(*sql.Rows), ret.Error(1)
}

// GetUserByUsernameAndPassword implements the GetUserByUsernameAndPassword method of a mock database.
func (m *MockDatabase) GetUserByUsernameAndPassword(username, password string) (*User, error) {
    ret := m.Called(username, password)
    return ret.Get(0).(*User), ret.Error(1)
}

// User represents a user in the database.
type User struct {
    Username string
    Password string
    LastLogin time.Time
}

// main is the entry point for the program.
func main() {
    mockDB := &MockDatabase{}
    mockDB.On("GetUserByUsernameAndPassword", "john", "password").Return(&User{
        Username: "john",
        Password: "password",
        LastLogin: time.Now(),
    }, nil)

    user, err := GetUser(mockDB, "john", "password")
    if err != nil {
        fmt.Println("Error getting user:", err)
    } else {
        fmt.Println("Welcome back, ", user.Username)
    }
}

4. 运行细粒度的测试

细粒度的测试专注于测试函数的小部分功能。通过运行细粒度的测试，我们可以更轻松地隔离和调试问题。例如，我们可以编写一个测试来检查 Max

import "testing"

func TestMaxElement(t *testing.T) {
    tests := []struct {
        name    string
        input   []int
        expected int
    }{
        {"Empty slice", []int{}, 0},
        {"Single element", []int{1}, 1},
        {"Multiple elements", []int{1, 2, 3}, 3},
    }

    for _, tt := range tests {
        actual := MaxElement(tt.input)
        assert.Equal(t, tt.expected, actual)
    }
}

2 Gunakan ujian dipacu jadual

Pengujian dipacu jadual boleh membantu mengatur dan memudahkan data ujian. Ia membolehkan kami menggunakan jadual untuk menyediakan input yang berbeza dan output yang diingini, dan kemudian melakukan ujian pada setiap input. Sebagai contoh, kita boleh menulis ujian dipacu jadual untuk menyemak fungsi Max:

rrreee

3 Tulis antara muka yang mengejek

Antara muka mengejek membolehkan kita menguji kelakuan fungsi apabila berinteraksi dengan. komponen lain. Kita boleh menggunakan rangka kerja mengejek (seperti ejekan) untuk menjana objek olok-olok yang melaksanakan antara muka yang kita pentingkan, tetapi tingkah lakunya boleh kita kawal. Sebagai contoh, kita boleh menulis mockDatabase untuk menguji fungsi yang menggunakan pangkalan data:

rrreee

4 Jalankan ujian halus 🎜🎜Ujian berbutir halus memfokuskan pada menguji sebahagian kecil fungsi. fungsinya. Dengan menjalankan ujian terperinci, kami boleh mengasingkan dan menyahpepijat isu dengan lebih mudah. Sebagai contoh, kita boleh menulis ujian untuk menyemak sama ada fungsi Max mengembalikan elemen maksimum: 🎜rrreee🎜 5. Menggunakan Alat Liputan 🎜🎜Alat liputan boleh membantu kami mengenal pasti baris kod yang diliputi oleh ujian . Ini membantu kami memastikan bahawa suite ujian kami adalah komprehensif dan boleh membimbing kami dalam menulis ujian tambahan untuk menampung kod yang hilang. 🎜🎜Kesimpulan🎜🎜Dengan mengguna pakai teknik pemfaktoran semula ini, kami boleh meningkatkan kebolehselenggaraan dan kebolehbacaan ujian unit fungsi dalam projek Go. Dengan mengekstrak fungsi penegasan, menggunakan ujian dipacu jadual, menulis antara muka mengejek, menjalankan ujian terperinci dan menggunakan alat liputan, kami boleh menulis kod ujian yang lebih dipercayai dan boleh diselenggara. 🎜

Atas ialah kandungan terperinci Petua pemfaktoran semula untuk ujian unit fungsi Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!