Go'da Mock işlevleri

Bağımlılıklar konusunda kafam karıştı. Bazı işlev çağrılarını sahte olanlarla değiştirebilmek istiyorum. İşte kodumun bir parçası:

func get_page(url string) string {
    get_dl_slot(url)
    defer free_dl_slot(url)
    
    resp, err := http.Get(url)
    if err != nil { return "" }
    defer resp.Body.Close()
    
    contents, err := ioutil.ReadAll(resp.Body)
    if err != nil { return "" }
    return string(contents)
}

func downloader() {
    dl_slots = make(chan bool, DL_SLOT_AMOUNT) // Init the download slot semaphore
    content := get_page(BASE_URL)
    links_regexp := regexp.MustCompile(LIST_LINK_REGEXP)
    matches := links_regexp.FindAllStringSubmatch(content, -1)
    for _, match := range matches{
        go serie_dl(match[1], match[2])
    }
}

downloader()Aslında http üzerinden bir sayfa almadan test edebilmek istiyorum - yani alay ederek get_page(sadece sayfa içeriğini bir dizge olarak döndürdüğü için daha kolay) veya http.Get().

Benzer bir sorunla ilgili görünen bu konuyu buldum . Julian Phillips bir çözüm olarak kitaplığı Withmock'u sunuyor , ancak işe yarayamıyorum . Dürüst olmak gerekirse, benim için büyük ölçüde kargo kült kodu olan test kodumun ilgili kısımları:

import (
    "testing"
    "net/http" // mock
    "code.google.com/p/gomock"
)
...
func TestDownloader (t *testing.T) {
    ctrl := gomock.NewController()
    defer ctrl.Finish()
    http.MOCK().SetController(ctrl)
    http.EXPECT().Get(BASE_URL)
    downloader()
    // The rest to be written
}

Test çıktısı aşağıdaki gibidir:

HATA: '_et / http' yüklenemedi: çıkış durumu 1 çıktı: paket yüklenemiyor: paket _et / http: paketler http (chunked.go) ve main (main_mock.go)
/ var / klasörler / z9 / içinde bulundu ql_yn5h550s6shtb9c5sggj40000gn / T / withmock570825607 / yol / src / _et / http

Withmock, test sorunum için bir çözüm mü? Çalışması için ne yapmalıyım?

Şahsen ben kullanmıyorum gomock(veya bu konuda herhangi bir alay çerçevesi; Go'da alay etmek onsuz çok kolay). Ya downloader()bir parametre olarak işleve bir bağımlılık geçirirdim ya da downloader()bir tür üzerinde bir yöntem yapardım ve tür get_pagebağımlılığı tutabilir :

Yöntem 1: get_page()Parametre olarak geçirindownloader()

type PageGetter func(url string) string

func downloader(pageGetterFunc PageGetter) {
    // ...
    content := pageGetterFunc(BASE_URL)
    // ...
}

Ana:

func get_page(url string) string { /* ... */ }

func main() {
    downloader(get_page)
}

Ölçek:

func mock_get_page(url string) string {
    // mock your 'get_page()' function here
}

func TestDownloader(t *testing.T) {
    downloader(mock_get_page)
}

Yöntem2: download()Bir tür yöntemi yapın Downloader:

Bağımlılığı bir parametre olarak geçirmek istemiyorsanız get_page(), bir türün bir üyesi de yapabilir ve download()bu türden bir yöntem oluşturabilir ve ardından şunları kullanabilirsiniz get_page:

type PageGetter func(url string) string

type Downloader struct {
    get_page PageGetter
}

func NewDownloader(pg PageGetter) *Downloader {
    return &Downloader{get_page: pg}
}

func (d *Downloader) download() {
    //...
    content := d.get_page(BASE_URL)
    //...
}

Ana:

func get_page(url string) string { /* ... */ }

func main() {
    d := NewDownloader(get_page)
    d.download()
}

Ölçek:

func mock_get_page(url string) string {
    // mock your 'get_page()' function here
}

func TestDownloader() {
    d := NewDownloader(mock_get_page)
    d.download()
}

Bunun yerine bir değişken kullanmak için işlev tanımınızı değiştirirseniz:

var get_page = func(url string) string {
    ...
}

Bunu testlerinizde geçersiz kılabilirsiniz:

func TestDownloader(t *testing.T) {
    get_page = func(url string) string {
        if url != "expected" {
            t.Fatal("good message")
        }
        return "something"
    }
    downloader()
}

Yine de dikkatli olun, geçersiz kıldığınız işlevin işlevselliğini test ederlerse diğer testleriniz başarısız olabilir!

Go yazarları, işleri test etmeyi kolaylaştırmak için koda test kancaları eklemek için Go standart kitaplığında bu deseni kullanır:

• https://golang.org/src/net/hook.go
• https://golang.org/src/net/dial.go#L248
• https://golang.org/src/net/dial_test.go#L701

Genel yapı yöntemlerinin arabirimleri uyguladığı ancak mantıklarının yalnızca bu arabirimleri parametre olarak alan özel (dışa aktarılmamış) işlevleri sarmalamakla sınırlı olduğu biraz farklı bir yaklaşım kullanıyorum . Bu size, neredeyse tüm bağımlılıklarla dalga geçmek için ihtiyaç duyacağınız ayrıntı düzeyini sağlar ve yine de test paketinizin dışından kullanabileceğiniz temiz bir API'ye sahip olursunuz.

Bunu anlamak için, test durumunuzdaki aktarılmamış yöntemlere (yani _test.godosyalarınızın içinden) erişiminizin olduğunu anlamanız zorunludur, böylece sarmalamadan başka içinde mantık bulunmayan dışa aktarılanları test etmek yerine bunları test edersiniz.

Özetlemek gerekirse: dışa aktarılanları test etmek yerine dışa aktarılmayan işlevleri test edin!

Bir örnek verelim. İki yöntemi olan bir Slack API yapımız olduğunu varsayalım:

• SendMessagegevşek bir webhook bir HTTP isteği gönderir yöntem
• SendDataSynchronouslyÜzerlerine dizeleri dolaşır bir dilim verildi ve aramaları yöntemi SendMessageher yineleme için

Öyleyse, SendDataSynchronouslyher seferinde bir HTTP isteğinde bulunmadan test etmek için alay etmemiz gerekir SendMessage, değil mi?

package main

import (
    "fmt"
)

// URI interface
type URI interface {
    GetURL() string
}

// MessageSender interface
type MessageSender interface {
    SendMessage(message string) error
}

// This one is the "object" that our users will call to use this package functionalities
type API struct {
    baseURL  string
    endpoint string
}

// Here we make API implement implicitly the URI interface
func (api *API) GetURL() string {
    return api.baseURL + api.endpoint
}

// Here we make API implement implicitly the MessageSender interface
// Again we're just WRAPPING the sendMessage function here, nothing fancy 
func (api *API) SendMessage(message string) error {
    return sendMessage(api, message)
}

// We want to test this method but it calls SendMessage which makes a real HTTP request!
// Again we're just WRAPPING the sendDataSynchronously function here, nothing fancy
func (api *API) SendDataSynchronously(data []string) error {
    return sendDataSynchronously(api, data)
}

// this would make a real HTTP request
func sendMessage(uri URI, message string) error {
    fmt.Println("This function won't get called because we will mock it")
    return nil
}

// this is the function we want to test :)
func sendDataSynchronously(sender MessageSender, data []string) error {
    for _, text := range data {
        err := sender.SendMessage(text)

        if err != nil {
            return err
        }
    }

    return nil
}

// TEST CASE BELOW

// Here's our mock which just contains some variables that will be filled for running assertions on them later on
type mockedSender struct {
    err      error
    messages []string
}

// We make our mock implement the MessageSender interface so we can test sendDataSynchronously
func (sender *mockedSender) SendMessage(message string) error {
    // let's store all received messages for later assertions
    sender.messages = append(sender.messages, message)

    return sender.err // return error for later assertions
}

func TestSendsAllMessagesSynchronously() {
    mockedMessages := make([]string, 0)
    sender := mockedSender{nil, mockedMessages}

    messagesToSend := []string{"one", "two", "three"}
    err := sendDataSynchronously(&sender, messagesToSend)

    if err == nil {
        fmt.Println("All good here we expect the error to be nil:", err)
    }

    expectedMessages := fmt.Sprintf("%v", messagesToSend)
    actualMessages := fmt.Sprintf("%v", sender.messages)

    if expectedMessages == actualMessages {
        fmt.Println("Actual messages are as expected:", actualMessages)
    }
}

func main() {
    TestSendsAllMessagesSynchronously()
}

Bu yaklaşımla ilgili sevdiğim şey, aktarılmamış yöntemlere bakarak bağımlılıkların ne olduğunu açıkça görebilmenizdir. Aynı zamanda, dışa aktardığınız API çok daha temizdir ve iletilmesi gereken daha az parametre vardır, çünkü buradaki gerçek bağımlılık sadece tüm bu arayüzleri uygulayan ana alıcıdır. Yine de her işlev potansiyel olarak yalnızca bir parçasına (bir, belki iki arayüz) bağlıdır ve bu da yeniden düzenleyicileri çok daha kolay hale getirir. Sadece fonksiyon imzalarına bakarak kodunuzun gerçekten nasıl bağlandığını görmek güzel, bence kod kokulu hale karşı güçlü bir araç.

İşleri kolaylaştırmak için, kodu burada oyun alanında çalıştırmanıza izin vermek için her şeyi tek bir dosyaya koyuyorum ama GitHub'daki tam örneğe de bakmanızı öneririm, işte slack.go dosyası ve burada slack_test.go .

Ve işte her şey.

Ben şöyle bir şey yapardım

Ana

var getPage = get_page
func get_page (...

func downloader() {
    dl_slots = make(chan bool, DL_SLOT_AMOUNT) // Init the download slot semaphore
    content := getPage(BASE_URL)
    links_regexp := regexp.MustCompile(LIST_LINK_REGEXP)
    matches := links_regexp.FindAllStringSubmatch(content, -1)
    for _, match := range matches{
        go serie_dl(match[1], match[2])
    }
}

Ölçek

func TestDownloader (t *testing.T) {
    origGetPage := getPage
    getPage = mock_get_page
    defer func() {getPage = origGatePage}()
    // The rest to be written
}

// define mock_get_page and rest of the codes
func mock_get_page (....

Ve _golang'dan kaçınırdım. CamelCase kullansan iyi olur

Uyarı: Bu, yürütülebilir dosya boyutunu biraz artırabilir ve biraz çalışma zamanı performansına mal olabilir. IMO, golang'ın makro veya işlev dekoratörü gibi bir özelliği varsa bu daha iyi olurdu.

API'sini değiştirmeden işlevlerle dalga geçmek istiyorsanız, en kolay yol, uygulamayı biraz değiştirmektir:

func getPage(url string) string {
  if GetPageMock != nil {
    return GetPageMock()
  }

  // getPage real implementation goes here!
}

func downloader() {
  if GetPageMock != nil {
    return GetPageMock()
  }

  // getPage real implementation goes here!
}

var GetPageMock func(url string) string = nil
var DownloaderMock func() = nil

Bu şekilde aslında bir işlevi diğerlerinden alay edebiliriz. Daha rahat olması için, bu tür alaycı standart metinler sağlayabiliriz:

// download.go
func getPage(url string) string {
  if m.GetPageMock != nil {
    return m.GetPageMock()
  }

  // getPage real implementation goes here!
}

func downloader() {
  if m.GetPageMock != nil {
    return m.GetPageMock()
  }

  // getPage real implementation goes here!
}

type MockHandler struct {
  GetPage func(url string) string
  Downloader func()
}

var m *MockHandler = new(MockHandler)

func Mock(handler *MockHandler) {
  m = handler
}

Test dosyasında:

// download_test.go
func GetPageMock(url string) string {
  // ...
}

func TestDownloader(t *testing.T) {
  Mock(&MockHandler{
    GetPage: GetPageMock,
  })

  // Test implementation goes here!

  Mock(new(MockHandler)) // Reset mocked functions
}

Birim testinin bu sorunun alanı olduğu düşünüldüğünde maymun kullanmanızı şiddetle tavsiye ederiz . Bu Paket, orijinal kaynak kodunuzu değiştirmeden alay testi yapmanızı sağlar. Diğer yanıtla karşılaştırın, daha "müdahaleci değil".

ana

type AA struct {
 //...
}
func (a *AA) OriginalFunc() {
//...
}

alay testi

var a *AA

func NewFunc(a *AA) {
 //...
}

monkey.PatchMethod(reflect.TypeOf(a), "OriginalFunc", NewFunc)

Kötü taraf:

• Dave.C tarafından hatırlatıldı, Bu yöntem güvenli değildir. Bu nedenle, birim testi dışında kullanmayın.
• Deyimsel olmayan Go.

İyi tarafı:

• Müdahaleci değildir. Ana kodu değiştirmeden bir şeyler yapmanızı sağlayın. Thomas'ın dediği gibi.
• En az kodla paketin davranışını (belki üçüncü şahıs tarafından sağlanmıştır) değiştirmenizi sağlar.