简单易懂的Go语言的单元测试教程

引入

谷歌一搜Go语言如何写单元测试，千篇一律都是关于整个包只有一个函数怎么实现测试。然而，很多情况下无法对复杂结构的代码进行测试。这篇博文教你在函数依赖于结构体的条件下实现单元测试。

最简单的例子

hello.go文件

package main import ( "fmt" ) func hello() string { return "Hello, Testing!" } func main() { fmt.Println(hello()) }

hello_test.go文件

package main import ( "testing" ) func TestHello(t *testing.T) { expectedStr := "Hello, Testing!" result := hello() if result != expectedStr { t.Fatalf("Expected %s, got %s", expectedStr, result) } }

hello.go文件与hello_test.go文件都是在main包下的，区别在于，单元测试文件要以XXX_test.go结尾。 这里我们要测试的是helle()函数的功能，其输入为空，理想输出是"Hello, Testing!"字符串。在测试文件中，首先用result保存hello()函数的结果，接着对照这个实际结果与理想结果是否相同。注意！！！错误输出函数t.Fatalf最好保留，不要换成t.error，不然很大可能编译不出。

重点来了，进阶内容

下面我要展示一个复杂的单元测试过程，代码很长。如果你没有耐心仔细看，你可以跟随我的文字捋清楚思路。 首先需要知道的前提，这个单元测试需要完成的是job.go文件当中run()函数的测试，以及Suspend()和Resume()的测试。run()函数的测试对应这些job_test.go文件当中的estPollerJobRunLog()函数，Suspend()和Resume()的测试对应这些job_test.go文件当中的TestPollerJobSuspendResume()函数。 这些需要被测试的函数，都是依赖于一个结构体的，单独根本无法测试，那怎么办呢？ 需要什么我们就给什么，先创建这个结构体实例，再用这个实例调用测试方法，比较实际结果和理想结果即可。 当然，如果想透彻的理解单元测试，就多花点时间仔细分析下面的代码结构。 job.go文件

package main import ( "fmt" "log" "net/http" "time" ) type Logger interface { Log(...interface{}) } type SuspendResumer interface { Suspend() error Resume() error } type Job interface { Logger SuspendResumer Run() error } type ServerPoller interface { PollServer() (string, error) } type PollerLogger struct{} type URLServerPoller struct { resourceUrl string } type PollSuspendResumer struct { SuspendCh chan bool ResumeCh chan bool } type PollerJob struct { WaitDuration time.Duration ServerPoller Logger *PollSuspendResumer } func NewPollerJob(resourceUrl string, waitDuration time.Duration) PollerJob { return PollerJob{ WaitDuration: waitDuration, Logger: &PollerLogger{}, ServerPoller: &URLServerPoller{ resourceUrl: resourceUrl, }, PollSuspendResumer: &PollSuspendResumer{ SuspendCh: make(chan bool), ResumeCh: make(chan bool), }, } } func (l *PollerLogger) Log(args ...interface{}) { log.Println(args...) } func (usp *URLServerPoller) PollServer() (string, error) { resp, err := http.Get(usp.resourceUrl) if err != nil { return "", err } return fmt.Sprint(usp.resourceUrl, " -- ", resp.Status), nil } func (ssr *PollSuspendResumer) Suspend() error { ssr.SuspendCh <- true return nil } func (ssr *PollSuspendResumer) Resume() error { ssr.ResumeCh <- true return nil } func (p PollerJob) Run() error { for { select { case <-p.PollSuspendResumer.SuspendCh: <-p.PollSuspendResumer.ResumeCh default: state, err := p.PollServer() if err != nil { p.Log("Error trying to get state: ", err) } else { p.Log(state) } time.Sleep(p.WaitDuration) } } return nil } func main() { var j Job j = NewPollerJob("http://nathanleclaire.com", 1*time.Second) go j.Run() time.Sleep(5 * time.Second) j.Log("Suspending monitoring of server for 5 seconds...") j.Suspend() time.Sleep(5 * time.Second) j.Log("Resuming job...") j.Resume() // Wait for a bit before exiting time.Sleep(5 * time.Second) }

job_test.go文件

package main import ( "errors" "fmt" "testing" "time" ) type ReadableLogger interface { Logger Read() string } type MessageReader struct { Msg string } func (mr *MessageReader) Read() string { return mr.Msg } type LastEntryLogger struct { *MessageReader } func (lel *LastEntryLogger) Log(args ...interface{}) { lel.Msg = fmt.Sprint(args...) } type DiscardFirstWriteLogger struct { *MessageReader writtenBefore bool } func (dfwl *DiscardFirstWriteLogger) Log(args ...interface{}) { if dfwl.writtenBefore { dfwl.Msg = fmt.Sprint(args...) } dfwl.writtenBefore = true } type FakeServerPoller struct { result string err error } func (fsp FakeServerPoller) PollServer() (string, error) { return fsp.result, fsp.err } func TestPollerJobRunLog(t *testing.T) { waitBeforeReading := 100 * time.Millisecond shortInterval := 20 * time.Millisecond longInterval := 200 * time.Millisecond testCases := []struct { p PollerJob logger ReadableLogger sp ServerPoller expectedMsg string }{ { p: NewPollerJob("madeup.website", shortInterval), logger: &LastEntryLogger{&MessageReader{}}, sp: FakeServerPoller{"200 OK", nil}, expectedMsg: "200 OK", }, { p: NewPollerJob("down.website", shortInterval), logger: &LastEntryLogger{&MessageReader{}}, sp: FakeServerPoller{"500 SERVER ERROR", nil}, expectedMsg: "500 SERVER ERROR", }, { p: NewPollerJob("error.website", shortInterval), logger: &LastEntryLogger{&MessageReader{}}, sp: FakeServerPoller{"", errors.New("DNS probe failed")}, expectedMsg: "Error trying to get state: DNS probe failed", }, { p: NewPollerJob("some.website", longInterval), // Discard first write since we want to verify that no // additional logs get made after the first one (time // out) logger: &DiscardFirstWriteLogger{MessageReader: &MessageReader{}}, sp: FakeServerPoller{"200 OK", nil}, expectedMsg: "", }, } for _, c := range testCases { c.p.Logger = c.logger c.p.ServerPoller = c.sp go c.p.Run() time.Sleep(waitBeforeReading) if c.logger.Read() != c.expectedMsg { t.Errorf("Expected message did not align with what was written:\n\texpected: %q\n\tactual: %q", c.expectedMsg, c.logger.Read()) } } } func TestPollerJobSuspendResume(t *testing.T) { p := NewPollerJob("foobar.com", 20*time.Millisecond) waitBeforeReading := 100 * time.Millisecond expectedLogLine := "200 OK" normalServerPoller := &FakeServerPoller{expectedLogLine, nil} logger := &LastEntryLogger{&MessageReader{}} p.Logger = logger p.ServerPoller = normalServerPoller // First start the job / polling go p.Run() time.Sleep(waitBeforeReading) if logger.Read() != expectedLogLine { t.Errorf("Line read from logger does not match what was expected:\n\texpected: %q\n\tactual: %q", expectedLogLine, logger.Read()) } // Then suspend the job if err := p.Suspend(); err != nil { t.Errorf("Expected suspend error to be nil but got %q", err) } // Fake the log line to detect if poller is still running newExpectedLogLine := "500 Internal Server Error" logger.MessageReader.Msg = newExpectedLogLine // Give it a second to poll if it's going to poll time.Sleep(waitBeforeReading) // If this log writes, we know we are polling the server when we're not // supposed to (job should be suspended). if logger.Read() != newExpectedLogLine { t.Errorf("Line read from logger does not match what was expected:\n\texpected: %q\n\tactual: %q", newExpectedLogLine, logger.Read()) } if err := p.Resume(); err != nil { t.Errorf("Expected resume error to be nil but got %q", err) } // Give it a second to poll if it's going to poll time.Sleep(waitBeforeReading) if logger.Read() != expectedLogLine { t.Errorf("Line read from logger does not match what was expected:\n\texpected: %q\n\tactual: %q", expectedLogLine, logger.Read()) } }

总结

看了这篇博文，大家以后都能够把单元测试当成小菜一碟的事情处理了。总结一句话，我们需要什么就在测试函数中创建什么。本篇代码来自GitHub的单元测试案例。