Tôi đang học Đi bằng cách mã hóa một dự án cá nhân nhỏ. Mặc dù nó nhỏ, tôi quyết định thực hiện kiểm tra đơn vị nghiêm ngặt để học thói quen tốt trên Go ngay từ đầu.

Các bài kiểm tra đơn vị tầm thường đều ổn và bảnh bao, nhưng hiện tại tôi đang bối rối với sự phụ thuộc; Tôi muốn có thể thay thế một số cuộc gọi chức năng bằng các cuộc gọi giả. Đây là một đoạn mã của tôi:

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

Tôi muốn có thể kiểm tra trình tải xuống () mà không thực sự có được một trang thông qua http - tức là bằng cách chế nhạo get_page (dễ dàng hơn vì nó chỉ trả về nội dung trang dưới dạng chuỗi) hoặc http.Get ().

Tôi tìm thấy chủ đề này: https://groups.google.com/forum/#!topic/golang-nuts/6AN1E2CJOxI dường như là về một vấn đề tương tự. Julian Phillips trình bày thư viện của mình, Withmock ( http://github.com/qur/withmock ) như một giải pháp, nhưng tôi không thể làm cho nó hoạt động được. Đây là những phần có liên quan trong mã thử nghiệm của tôi, phần lớn là mã sùng bái đối với tôi, phải trung thực:

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
}

Đầu ra thử nghiệm như sau:

ERROR: Failed to install '_et/http': exit status 1
output:
can't load package: package _et/http: found packages http (chunked.go) and main (main_mock.go) in /var/folders/z9/ql_yn5h550s6shtb9c5sggj40000gn/T/withmock570825607/path/src/_et/http

Withmock có phải là giải pháp cho vấn đề thử nghiệm của tôi không? Tôi nên làm gì để nó hoạt động?

Kudos cho bạn để thực hành thử nghiệm tốt! :)

Cá nhân, tôi không sử dụng gomock(hoặc bất kỳ khuôn khổ chế giễu nào cho vấn đề đó; việc nhạo báng trong Go rất dễ dàng nếu không có nó). Tôi sẽ chuyển một phụ thuộc cho downloader()hàm dưới dạng tham số hoặc tôi sẽ tạo downloader()một phương thức trên một kiểu và kiểu có thể giữ get_pagephụ thuộc:

Phương pháp 1: Truyền get_page()dưới dạng tham số củadownloader()

type PageGetter func(url string) string

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

Chủ yếu:

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

func main() {
    downloader(get_page)
}

Kiểm tra:

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

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

download()Phương thức 2 : Tạo một phương thức của một loại Downloader:

Nếu bạn không muốn truyền phụ thuộc làm tham số, bạn cũng có thể tạo get_page()thành viên của một loại và tạo download()phương thức của loại đó, sau đó có thể sử dụng 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)
    //...
}

Chủ yếu:

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

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

Kiểm tra:

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

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

Nếu bạn thay đổi định nghĩa hàm để sử dụng một biến thay thế:

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

Bạn có thể ghi đè nó trong các bài kiểm tra của bạn:

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

Mặc dù cẩn thận, các thử nghiệm khác của bạn có thể thất bại nếu chúng kiểm tra chức năng của chức năng bạn ghi đè!

Các tác giả của Go sử dụng mẫu này trong thư viện chuẩn Go để chèn các móc kiểm tra vào mã để làm cho mọi thứ dễ kiểm tra hơn:

https://golang.org/src/net/hook.go

https://golang.org/src/net/dial.go#L248

https://golang.org/src/net/dial_test.go#L701

Tôi đang sử dụng một cách tiếp cận hơi khác trong đó các phương thức cấu trúc công cộng thực hiện các giao diện nhưng logic của chúng bị giới hạn chỉ bao bọc các hàm riêng (không được báo cáo) lấy các giao diện đó làm tham số. Điều này cung cấp cho bạn mức độ chi tiết mà bạn sẽ cần để chế nhạo hầu như mọi phụ thuộc và vẫn có API sạch để sử dụng từ bên ngoài bộ thử nghiệm của bạn.

Để hiểu điều này, bắt buộc phải hiểu rằng bạn có quyền truy cập vào các phương thức không được báo cáo trong trường hợp thử nghiệm của bạn (nghĩa là từ trong _test.gotệp của bạn ) để bạn kiểm tra chúng thay vì kiểm tra các phương thức xuất khẩu không có logic bên trong gói.

Tóm lại: kiểm tra các hàm không được báo cáo thay vì kiểm tra các hàm đã xuất!

Hãy làm một ví dụ. Giả sử chúng ta có cấu trúc API Slack có hai phương thức:

• các SendMessagephương pháp đó sẽ gửi một yêu cầu HTTP đến một webhook Slack
• các SendDataSynchronouslyphương pháp đó được đưa ra một lát chuỗi lặp trên họ và gọi SendMessagecho mỗi lần lặp

Vì vậy, để kiểm tra SendDataSynchronouslymà không thực hiện yêu cầu HTTP mỗi lần chúng ta sẽ phải giả SendMessage, phải không?

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

Điều tôi thích về cách tiếp cận này là bằng cách xem xét các phương pháp không được báo cáo, bạn có thể thấy rõ các phụ thuộc là gì. Đồng thời, API mà bạn xuất sẽ sạch hơn rất nhiều và có ít tham số hơn để vượt qua vì sự phụ thuộc thực sự ở đây chỉ là trình nhận cha mẹ đang thực hiện tất cả các giao diện đó. Tuy nhiên, mọi chức năng đều có khả năng chỉ phụ thuộc vào một phần của nó (một, có thể là hai giao diện) giúp cho việc tái cấu trúc dễ dàng hơn rất nhiều. Thật tuyệt khi thấy cách mã của bạn thực sự được ghép nối chỉ bằng cách xem các chữ ký hàm, tôi nghĩ rằng nó tạo ra một công cụ mạnh mẽ chống lại mùi mã.

Để làm cho mọi thứ dễ dàng, tôi đặt mọi thứ vào một tệp để cho phép bạn chạy mã trong sân chơi ở đây nhưng tôi khuyên bạn cũng nên xem ví dụ đầy đủ trên GitHub, đây là tệp slack.go và ở đây là slack_test.go .

Và đây là toàn bộ :)

Tôi sẽ làm một cái gì đó như,

Chủ yếu

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

Kiểm tra

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 (....

Và tôi sẽ tránh _ở golang. Sử dụng tốt hơn camelCase

Cảnh báo: Điều này có thể làm tăng kích thước tệp thực thi một chút và tốn một ít hiệu năng thời gian chạy. IMO, điều này sẽ tốt hơn nếu golang có tính năng như macro hoặc trang trí chức năng.

Nếu bạn muốn mô phỏng các chức năng mà không thay đổi API của nó, cách dễ nhất là thay đổi cách thực hiện một chút:

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

Bằng cách này, chúng ta thực sự có thể giả định một chức năng trong số các chức năng khác. Để thuận tiện hơn, chúng tôi có thể cung cấp nồi hơi chế nhạo như vậy:

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

Trong tệp thử nghiệm:

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

Xem xét bài kiểm tra đơn vị là lĩnh vực của câu hỏi này, rất khuyến khích bạn sử dụng https://github.com/bouk/monkey . Gói này làm cho bạn thử nghiệm mà không thay đổi mã nguồn ban đầu của bạn. So với câu trả lời khác, nó "không xâm phạm" hơn

CHỦ YẾU

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

KIỂM TRA

var a *AA

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

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

Mặt xấu là:

- Nhắc nhở bởi Dave.C, Phương pháp này không an toàn. Vì vậy, không sử dụng nó bên ngoài bài kiểm tra đơn vị.

- Là không thành ngữ Đi.

Mặt tốt là:

++ Không xâm phạm. Làm cho bạn làm mọi thứ mà không thay đổi mã chính. Giống như Thomas đã nói.

++ Làm cho bạn thay đổi hành vi của gói (có thể được cung cấp bởi bên thứ ba) với ít mã nhất.