Bagaimana untuk menulis ujian fungsi Golang yang mantap dan boleh dipercayai?

Menulis ujian fungsi bahasa Go yang mantap dan boleh dipercayai termasuk: Kebergantungan olok-olok: Gunakan perpustakaan seperti Mockito untuk mencipta objek tiruan untuk mengasingkan fungsi. Mengendalikan concurrency: Gunakan rangka kerja seperti GoConvey untuk menulis ujian concurrency untuk mensimulasikan situasi concurrency. Tulis ujian penyepaduan: Uji interaksi kod anda dengan sistem luaran, seperti pangkalan data atau API.

Cara menulis ujian fungsi Golang yang mantap dan boleh dipercayai

Menulis ujian fungsi yang mantap dan boleh dipercayai di Golang adalah penting untuk memastikan ketepatan dan kebolehpercayaan kod anda. Artikel ini meneroka cara untuk menulis ujian yang berkesan, termasuk kebergantungan mengejek, mengendalikan serentak dan menulis ujian penyepaduan.

Kebergantungan olok-olok

Kebergantungan olok-olok boleh membantu mengasingkan fungsi dan menguji cara ia berkelakuan dalam pelbagai keadaan. Mockito ialah perpustakaan olok-olok Golang yang popular yang membenarkan penciptaan objek olok-olok untuk menggantikan kebergantungan sebenar.

import (
    "fmt"
    "testing"

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

type MyDependency interface {
    DoSomething() error
}

type MyMockDependency struct {
    mock.Mock
}

func (m *MyMockDependency) DoSomething() error {
    args := m.Called()
    return args.Error(0)
}

func TestMyFunction(t *testing.T) {
    mockDependency := &MyMockDependency{}
    mockDependency.On("DoSomething").Return(nil)

    if err := MyFunction(mockDependency); err != nil {
        t.Errorf("MyFunction returned an unexpected error: %v", err)
    }
}

Mengendalikan concurrency

Di Golang, concurrency adalah perkara biasa. Oleh itu, ujian kefungsian mesti mampu menangani kesan konkurensi. GoConvey ialah rangka kerja untuk menulis ujian serentak.

import (
    "testing"

    "github.com/smartystreets/goconvey/convey"
)

func TestMyConcurrentFunction(t *testing.T) {
    convey.Convey("Given a concurrent function", t, func() {
        done := make(chan struct{})
        wg := new(sync.WaitGroup)
        numWorkers := 10

        wg.Add(numWorkers)
        for i := 0; i < numWorkers; i++ {
            go func(done chan<- struct{}, wg *sync.WaitGroup) {
                MyConcurrentFunction()
                wg.Done()
            }(done, wg)
        }

        close(done)
        wg.Wait()
    })
}

Tulis Ujian Integrasi

Ujian integrasi menguji interaksi kod anda dengan sistem luaran seperti pangkalan data atau API. Mereka penting untuk menemui masalah yang berpotensi apabila kod anda berinteraksi dengan komponen lain.

import (
    "fmt"
    "os"
    "testing"

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

func TestMyIntegratedFunction(t *testing.T) {
    db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        t.Fatalf("failed to open database connection: %v", err)
    }
    defer db.Close()

    result, err := MyIntegratedFunction(db)
    if err != nil {
        t.Errorf("MyIntegratedFunction returned an unexpected error: %v", err)
    }

    assert.Equal(t, "expected result", result)
}

Dengan mengikuti amalan terbaik ini, anda boleh menulis ujian fungsi Golang yang mantap dan boleh dipercayai untuk meningkatkan kualiti dan kebolehpercayaan kod anda.

Atas ialah kandungan terperinci Bagaimana untuk menulis ujian fungsi Golang yang mantap dan boleh dipercayai?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!