"测试在 Golang 的处理程序中调用该方法"

Question

I am implementing a API in Golang. I have a endpoint where I am calling a method with parameters of other package. Now I need to check that, that method has been called in the request.

Below is the small similar scenario what I am doing and what I am expecting.

My handler

package myPackage
import (
    "log"
    "github.com/myrepo/notifier" // my another package
)

func MyHandler(writer http.ResponseWriter, request *http.Request) { 
    // ...
    // ...

    notifier.Notify(4, "sdfsdf")

    // ...
    // ...

}

Testing handler

func TestMyHandler(t *testing.T) {
    // Here I want to 
    req, _ := http.NewRequest("GET", "/myendpoint", nil)
    // ... Want to test that notifier.Notify is called
    // ...
}

In the TestMyHandler, I want to check that notifier.Notify has called.

Findings

I tried to understand the AssertNumberOfCalls , func (*Mock) Called , and func (*Mock) MethodCalled but I am not sure how to use them :(.

I am a newbie in Golang and really exicted to do that. Please let me know if I missed anything or you may need more information for more understaing.

Answer 1

Want to test that notifier.Notify is called.

No you don't. You are interested in that the handler does what it should do and this seems to consist of two things:

1. Return the right response (easy to test with a net/http/httptest.ResponseRecorder), and

2. Has some noticeable side effect, here issue some notification.

To test 2. you test that the notification was issued, not that some function was called. Whatever notify.Notify results in (eg a database entry, a file, some HTTP call) should be tested. Formally this is no longer unit testing but testing for side effects is never strict unit testing.

What you can do: Wrap your handler logic into some object and observe that objects state. Ugly. Don't.

Answer 2

This is a good opportunity to use dependency injection and interfaces.

Namely, we need to extract the concept of a Notifier

(warning: code not tested directly)

type Notifier interface {
    Notify(int, string)() error
}

Now to avoid any confusion with the notifier library, use a local alias.

import "github.com/myrepo/notifier" mynotifier

Then, because the library you're using exports it as a function, not within a struct, we'll need to make a struct that implements our interface

type myNotifier struct {}

func (mn *myNotifier) Notify(n int, message string) error {
  return mynotifier.Notify(n, message)
}

Then you modify your function:

func MyHandler(writer http.ResponseWriter, request *http.Request, notifier Notifier) { 
    // ...
    // ...

    notifier.Notify(4, "sdfsdf")

    // ...
    // ...

}

Then in your test, you're now free to send in a spy Notifier

type spyNotifier struct {
  called boolean
}

func (n *spyNotifier) Notify(n int, msg string) error {
  n.called = true
  return
}

Answer 3

This approach is similar to Mathew's answer<\/a> , but uses the mock<\/a> package from testify<\/a> instead. Here, you create a mock implementation of the Notifier, register the method call, and assert that the method has been called with the expected arguments.