Go 中的模拟函数

Question

我对依赖关系感到困惑。我希望能够用模拟函数调用替换一些函数调用。这是我的代码的 sn-p：

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() 而无需通过 http 实际获取页面 - 即通过模拟 get_page（更容易，因为它仅将页面内容作为字符串返回）或 http.Get()。

我发现this thread 似乎是一个类似的问题。 Julian Phillips 提出了他的库 Withmock 作为解决方案，但我无法让它工作。这是我的测试代码的相关部分，老实说，这对我来说主要是货物崇拜代码：

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
}

测试输出如下：

错误：安装 '_et/http' 失败：退出状态 1 输出：无法加载 package: package _et/http: 找到包 http (chunked.go) 和 main (main_mock.go) 在
/var/folders/z9/ql_yn5h550s6shtb9c5sggj40000gn/T/withmock570825607/path/src/_et/http

Withmock 能否解决我的测试问题？我应该怎么做才能让它工作？

Answer 1

就我个人而言，我不使用gomock（或任何与此相关的模拟框架；没有它，Go 中的模拟非常容易）。我要么将依赖项作为参数传递给downloader() 函数，要么将downloader() 设为一个类型的方法，并且该类型可以保存get_page 依赖项：

方法一：将get_page()作为downloader()的参数传递

type PageGetter func(url string) string

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

主要：

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

func main() {
    downloader(get_page)
}

测试：

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

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

方法2：使download()成为Downloader类型的方法：

如果您不想将依赖项作为参数传递，您还可以将get_page() 设为某个类型的成员，并将download() 设为该类型的方法，然后可以使用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)
    //...
}

主要：

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

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

测试：

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

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

Answer 2

如果您将函数定义更改为使用变量：

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

您可以在测试中覆盖它：

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

但请注意，如果您的其他测试测试您覆盖的函数的功能，它们可能会失败！

Go 作者在 Go 标准库中使用这种模式将测试钩子插入到代码中，以使测试更容易：

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

Answer 3

我使用了一种稍微不同的方法，其中 public 结构方法实现 interfaces 但它们的逻辑仅限于包装 private（未导出）将这些接口作为参数的函数。这为您提供了模拟几乎任何依赖项所需的粒度，同时拥有一个干净的 API 可以在您的测试套件之外使用。

要理解这一点，必须了解您可以访问测试用例中未导出的方法（即从您的_test.go 文件中），以便您测试这些方法而不是测试导出的方法除了包装之外没有任何逻辑。

总结一下：测试未导出的函数，而不是测试导出的函数！

让我们举个例子。假设我们有一个 Slack API 结构，它有两个方法：

• SendMessage 方法将 HTTP 请求发送到 Slack webhook
• SendDataSynchronously 方法给定一个字符串切片迭代它们并为每次迭代调用 SendMessage

所以为了测试SendDataSynchronously而不每次都发出HTTP请求，我们必须模拟SendMessage，对吧？

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

我喜欢这种方法的地方在于，通过查看未导出的方法，您可以清楚地看到依赖关系是什么。同时，您导出的 API 更简洁，传递的参数更少，因为这里真正的依赖关系只是实现所有这些接口的父接收器。然而，每个函数都可能只依赖于它的一部分（一个，也许是两个接口），这使得重构变得更加容易。很高兴通过查看函数签名来了解您的代码是如何真正耦合的，我认为它是一个强大的防止代码异味的工具。

为方便起见，我将所有内容放在一个文件中，以便您运行 playground here 中的代码，但我建议您也查看 GitHub 上的完整示例，这里是 slack.go 文件，这里是 @987654323 @。

还有here 整件事。

Answer 4

我会做类似的事情，

主要

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

测试

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

我会避免在 golang 中使用 _。 Better use camelCase

Answer 5

警告：这可能会稍微增加可执行文件的大小并降低运行时性能。 IMO，如果golang具有宏或函数装饰器等功能会更好。

如果你想在不改变 API 的情况下模拟函数，最简单的方法是稍微改变实现：

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

这样我们实际上可以从其他函数中模拟出一个函数。为了更方便，我们可以提供这样的模拟样板：

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

在测试文件中：

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

Answer 6

最简单的方法是将函数设置为全局变量，然后在测试之前设置自定义方法

// package base36

func GenerateRandomString(length int) string {
    // your real code
}


// package teamManager

var RandomStringGenerator = base36.GenerateRandomString

func (m *TeamManagerService) CreateTeam(ctx context.Context) {
 
    // we are using the global variable
    code = RandomStringGenerator(5)
 
    // your application logic

    return  nil
}

在您的测试中，您必须首先模拟该全局变量

    teamManager.RandomStringGenerator = func(length int) string {
        return "some string"
    }
    
   service := &teamManager.TeamManagerService{}
   service.CreateTeam(context.Background())
   // now when we call any method that user teamManager.RandomStringGenerator, it will call our mocked method

另一种方法是将 RandomStringGenerator 作为依赖项传递并将其存储在 TeamManagerService 中并像这样使用它：

// package teamManager

type TeamManagerService struct {
   RandomStringGenerator func(length int) string
}

// in this way you don't need to change your main/where this code is used
func NewTeamManagerService() *TeamManagerService {
    return &TeamManagerService{RandomStringGenerator: base36.GenerateRandomString}
}

func (m *TeamManagerService) CreateTeam(ctx context.Context) {
 
    // we are using the struct field variable
    code = m.RandomStringGenerator(5)
 
    // your application logic

    return  nil
}

在您的测试中，您可以使用自己的自定义函数

    myGenerator = func(length int) string {
        return "some string"
    }
    
   service := &teamManager.TeamManagerService{RandomStringGenerator: myGenerator}
   service.CreateTeam(context.Background())

你正在像我一样使用 testify :D 你可以这样做

// this is the mock version of the base36 file
package base36_mock

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

var Mock = mock.Mock{}

func GenerateRandomString(length int) string {
    args := Mock.Called(length)
    return args.String(0)
}

在您的测试中，您可以使用自己的自定义函数

   base36_mock.Mock.On("GenerateRandomString", 5).Return("my expmle code for this test").Once()
    
   service := &teamManager.TeamManagerService{RandomStringGenerator: base36_mock.GenerateRandomString}
   service.CreateTeam(context.Background())

Answer 7

考虑到单元测试是这个问题的领域，强烈推荐你使用monkey。该软件包使您可以在不更改原始源代码的情况下进行模拟测试。与其他答案相比，它更“非侵入性”。

主要

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

模拟测试

var a *AA

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

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

不好的一面是：

• Dave.C 提醒，此方法不安全。所以不要在单元测试之外使用它。
• 是非惯用的 Go。

好的一面是：

• 是非侵入式的。让你在不改变主代码的情况下做事。就像托马斯说的那样。
• 让您以最少的代码更改包的行为（可能由第三方提供）。