Go带有自己的测试功能,具有运行测试和基准所需的一切。 与大多数其他编程语言不同,尽管存在一些测试框架,但通常不需要单独的测试框架。
基本使用
main.go:
package main
import (
"fmt"
)
func main() {
fmt.Println(Sum(4,5))
}
func Sum(a, b int) int {
return a + b
}
main_test.go:
package main
import (
"testing"
)
// 测试方法需以`Test`开头
func TestSum(t *testing.T) {
got := Sum(1, 2)
want := 3
if got != want {
t.Errorf("Sum(1, 2) == %d, want %d", got, want)
}
}
使用go test命令来运行go测试:
$ go test
ok test_app 0.005s
使用-v来查看每个test的结果:
$ go test -v
=== RUN TestSum
--- PASS: TestSum (0.00s)
PASS
ok _/tmp 0.000s
使用./...来测试子目录
$ go test -v ./...
ok github.com/me/project/dir1 0.008s
=== RUN TestSum
--- PASS: TestSum (0.00s)
PASS
ok github.com/me/project/dir2 0.008s
=== RUN TestDiff
--- PASS: TestDiff (0.00s)
PASS
运行特定测试:如果有多个测试,并且您想运行特定测试,则可以这样进行:
go test -v -run=<TestName> // will execute only test with this name
如:
go test -v run=TestSum
表驱动的单元测试
此类测试是用于使用预定义的输入和输出值进行测试的流行技术。
创建一个名为main.go的文件,其内容如下:
package main
import (
"fmt"
)
func main() {
fmt.Println(Sum(4, 5))
}
func Sum(a, b int) int {
return a + b
}
运行之后将看到输出为9,尽管Sum函数看起来非常简单,但是测试代码是一个好主意。 为此,我们在与main.go相同的文件夹中创建另一个名为main_test.go的文件,其中包含以下代码:
package main
import (
"testing"
)
// Test开头
func TestSum(t *testing.T) {
// Note that the data variable is of type array of anonymous struct,
// which is very handy for writing table-driven unit tests.
data := []struct {
a, b, res int
}{
{1, 2, 3},
{0, 0, 0},
{1, -1, 0},
{2, 3, 5},
{1000, 234, 1234},
}
for _, d := range data {
if got := Sum(d.a, d.b); got != d.res {
t.Errorf("Sum(%d, %d) == %d, want %d", d.a, d.b, got, d.res)
}
}
}
如您所见,将创建一些匿名结构,每个匿名结构都有一组输入和预期结果。 这样一来,就可以在一起创建大量测试用例,然后循环执行,从而减少了代码重复并提高了清晰度。
使用setUp和tearDown功能进行测试
您可以设置setUp和tearDown函数。
setUp函数可为您的环境做好测试准备。
tearDown函数执行回滚。
当您无法修改数据库并且需要创建一个对象来模拟数据库带来的对象或需要在每次测试中初始化配置时,这是一个不错的选择。
一个愚蠢的例子是:
// Standard numbers map
var numbers map[string]int = map[string]int{"zero": 0, "three": 3}
// TestMain will exec each test, one by one
func TestMain(m *testing.M) {
// exec setUp function
setUp("one", 1)
// exec test and this returns an exit code to pass to os
retCode := m.Run()
// exec tearDown function
tearDown("one")
// If exit code is distinct of zero,
// the test will be failed (red)
os.Exit(retCode)
}
// setUp function, add a number to numbers slice
func setUp(key string, value int) {
numbers[key] = value
}
// tearDown function, delete a number to numbers slice
func tearDown(key string) {
delete(numbers, key)
}
// First test
func TestOnePlusOne(t *testing.T) {
numbers["one"] = numbers["one"] + 1
if numbers["one"] != 2 {
t.Error("1 plus 1 = 2, not %v", value)
}
}
// Second test
func TestOnePlusTwo(t *testing.T) {
numbers["one"] = numbers["one"] + 2
if numbers["one"] != 3 {
t.Error("1 plus 2 = 3, not %v", value)
}
}
下一个示例将是准备数据库进行测试并进行回滚
// ID of Person will be saved in database
personID := 12345
// Name of Person will be saved in database
personName := "Toni"
func TestMain(m *testing.M) {
// You create an Person and you save in database
setUp(&Person{
ID: personID,
Name: personName,
Age: 19,
})
retCode := m.Run()
// When you have executed the test, the Person is deleted from database
tearDown(personID)
os.Exit(retCode)
}
func setUp(P *Person) {
// ...
db.add(P)
// ...
}
func tearDown(id int) {
// ...
db.delete(id)
// ...
}
func getPerson(t *testing.T) {
P := Get(personID)
if P.Name != personName {
t.Error("P.Name is %s and it must be Toni", P.Name)
}
}
基准测试
如果要衡量基准,请添加如下测试方法:
sum.go:
package sum
// Sum calculates the sum of two integers
func Sum(a, b int) int {
return a + b
}
sum_test.go:
package sum
import "testing"
func BenchmarkSum(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = Sum(2, 3)
}
}
运行基准测试:
$ go test -bench=.
BenchmarkSum-8 2000000000 0.49 ns/op
ok so/sum 1.027s
示例测试(自我记录测试)
这种类型的测试可确保您的代码正确编译,并将出现在项目的生成文档中。 除此之外,示例测试还可以断言您的测试产生了正确的输出。
sum.go:
package sum
func Sum(a, b int) int {
return a + b
}
sum_test.go:
package sum
import "fmt"
func ExampleSum() {
x := Sum(1, 2)
fmt.Println(x)
fmt.Println(Sum(-1, -1))
fmt.Println(Sum(0, 0))
// Output:
// 3
// -2
// 0
}
要执行测试,请在包含这些文件的文件夹中运行go test或将这两个文件放在名为sum的子文件夹中,然后从父文件夹中执行go test ./sum。 将获得类似于以下的输出:
ok so/sum 0.005s
如果您想知道这如何测试您的代码,这是另一个示例函数,该函数实际上未通过测试:
func ExampleSum_fail() {
x := Sum(1, 2)
fmt.Println(x)
// Output:
// 5
}
运行go test时,将获得以下输出:
$ go test
--- FAIL: ExampleSum_fail (0.00s)
got:
3
want:
5
FAIL
exit status 1
FAIL so/sum 0.006s
如果要查看sum软件包的文档,请运行:
go doc -http=:6060
打开链接: http://localhost:6060/pkg/FOLDER/sum/, 其中FOLDER是包含sum软件包的文件夹(在本示例中为)。 sum方法的文档如下所示:
测试HTTP请求
main.go:
package main
import (
"fmt"
"io/ioutil"
"log"
"net/http"
)
func fetchContent(url string) (string, error) {
res, err := http.Get(url)
if err != nil {
return "", nil
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return "", err
}
return string(body), nil
}
func main() {
url := "https://example.com/"
content, err := fetchContent(url)
if err != nil {
log.Fatal(err)
}
fmt.Println("Content:", content)
}
main_test.go:
package main
import (
"fmt"
"net/http"
"net/http/httptest"
"testing"
)
func Test_fetchContent(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "hello world")
}))
defer ts.Close()
content, err := fetchContent(ts.URL)
if err != nil {
t.Error(err)
}
want := "hello world"
if content != want {
t.Errorf("Got %q, want %q", content, want)
}
}
在测试中设置/重置模拟功能
本示例说明如何模拟与单元测试无关的函数调用,然后使用defer语句将模拟的函数调用重新分配回其原始函数。
var validate = validateDTD
// ParseXML parses b for XML elements and values, and returns them as a map of
// string key/value pairs.
func ParseXML(b []byte) (map[string]string, error) {
// we don't care about validating against DTD in our unit test
if err := validate(b); err != nil {
return err
}
// code to parse b etc.
}
func validateDTD(b []byte) error {
// get the DTD from some external storage, use it to validate b etc.
}
In our unit test,
func TestParseXML(t *testing.T) {
// assign the original validate function to a variable.
originalValidate = validate
// use the mockValidate function in this test.
validate = mockValidate
// defer the re-assignment back to the original validate function.
defer func() {
validate = originalValidate
}()
var input []byte
actual, err := ParseXML(input)
// assertion etc.
}
func mockValidate(b []byte) error {
return nil // always return nil since we don't care
}
查看HTML格式的代码覆盖率
正常运行go测试,但带有coverprofile标志。 然后使用go工具以HTML格式查看结果。
go test -coverprofile=c.out
go tool cover -html=c.out