go语言接口测试 go语言测试框架

Go语言中自带有一个轻量级的测试框架testing 和自带的go test命令来实现单元测试和性能测试，testing框架和其他语言中的测试框架类似，可以基于这个框架写针对相应函数的测试用例，也可以基于该框架写相应的压力测试用例。通过单元测试，可以解决如下问题：

1）确保每个函数是可运行，并且运行结果是正确的

2）确保写出来的代码性能是好的

3）单元测试能及时的发现程序设计或实现的逻辑错误，使问题及早暴露，便于问题的定位解决，而性能测试的重点在于发现程序设计上的一些问题，让程序能够在高并发的情况下保持稳定。

1.单元测试使用testing包

testing 提供对 Go 包的自动化测试的支持。通过 `go test` 命令，能够自动执行如下形式的任何函数：

func TestXxx(*testing.T)

其中 Xxx 可以是任何字母数字字符串（但第一个字母不能是 [a-z]），用于识别测试例程。

在这些函数中，使用 Error, Fail 或相关方法来发出失败信号。要编写一个新的测试套件，需要创建一个名称以 _test.go 结尾的文件，该文件包含 `TestXxx` 函数，如上所述。 将该文件放在与被测试的包相同的包中。该文件将被排除在正常的程序包之外，但在运行 “go test” 命令时将被包含。

func (*T) Fatalf

func (c *T) Fatalf(format string, args ...interface{})

调用 Fatalf 相当于在调用 Logf 之后调用 FailNow 。

2.案例

cal.go

package testcase01

//被测很难受
func addUpper(n int) int {
    res := 0
    for i := 1; i < n+1; i++ {
        res += i
    }
    return res
}
func getSub(n1 int, n2 int) int {

    return n1 - n2
}

cal_test.go

package testcase01

import (
    "testing"
)

//编写测试用例，去测试addUpper是否正确

func TestAddUpper(t *testing.T) {
    res := addUpper(10)
    if res != 55 {
        //fmt.Printf("AddUpper(10)执行错误，期望值%v，实际值%v\n", 55, res)
        t.Fatalf("AddUpper(10)执行错误，期望值%v，实际值%v\n", 55, res)
    }
    //如果正确，输出日志
    t.Logf("AddUpper(10)执行正确...")
}
func TestGetSub2(t *testing.T) {
    res := getSub(10, 3)
    if res != 7 {
        //fmt.Printf("AddUpper(10)执行错误，期望值%v，实际值%v\n", 55, res)
        t.Fatalf("getSub(10,3)执行错误，期望值%v，实际值%v\n", 7, res)
    }
    //如果正确，输出日志
    t.Logf("getSub(10,3)执行正确!!!...")
}

sub_test.go

package testcase01

import (
    "testing"
)

func TestGetSub(t *testing.T) {
    res := getSub(10, 3)
    if res != 7 {
        //fmt.Printf("AddUpper(10)执行错误，期望值%v，实际值%v\n", 55, res)
        t.Fatalf("getSub(10,3)执行错误，期望值%v，实际值%v\n", 7, res)
    }
    //如果正确，输出日志
    t.Logf("getSub(10,3)执行正确...")
}

 

总结：

1）测试用例文件名必须以 _test.go结尾。比如cal_test.go，cal不是固定的。

2）测试用例函数必须以Test开头，一般来说就是Test+被测试的函数名，比如TestAddUpper。

3）TestAddUpeer（t *testing.T）的形参类型必须是*testing.T

4）一个测试用例文件中，可以有多个测试用例函数，比如TestAddUpper、TestSub

5）testing可以引用到同文件夹下其他go文件的以小写名字开头如addupper的函数

6）运行测试用例指令 

（1）cmd > go test(如果运行正确，无日志，错误时，会输出日志

  (2) cmd > go test -v (运行正确或是错误，都输出日志)

7）当出现错误时，可以用t.Fatalf来格式化输出错误信息，并退出程序

8）t.logf方法可以输出相应的日志

9）测试用例函数，并没有放在main函数中，也执行了，这就是测试用例的方便之处

10）PASS表示测试用例运行成功，FALL表示测试用例运行失败

11）如果有多个测试文件，但是只需要测试单个文件，一定要带上被测试的源文件

go test -v cal_test.go cal.go

12）测试当个方法,只需要指定方法名，不需要指定文件名

go test -v -test.run TestAddUpper

3.综合案例

1）编写一个Monster结构体，字段Name,Age,Skill

2）结合Monster绑定方法Store,可以将一个Monster变量（对象），序列化后保存到文件中

3）给Monster绑定方法ReStore，可以将一个序列化的Monster从文件中读取，并反序列化为Monster对象，检查反序列化，名字正确

4）编程测试用例文件store_test.go，编写测试用例函数TestStore和TestRestore进行测试

monster.go (bufio方式)

package monster

import (
    "bufio"
    "encoding/json"
    "fmt"
    "io"
    "os"
)

type Monster struct {
    Name  string
    Age   int
    Skill string
}

//序列化monster变量后保存到文件中
func (monster *Monster) Store() bool {
    //输出结构体monster
    fmt.Printf("结构体为：%v\n", monster)
    //序列化monster
    data, err := json.Marshal(monster)
    if err != nil {
        fmt.Printf("序列化失败：%v", err)
        return false
    }
    fmt.Printf("序列化后的monster为：%v\n", string(data))
    //将序列化的monster存储到文件中
    filePath := "/Users/Tsunami/Documents/monster.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("打开文件失败：%v", err)
        return false
    }
    defer file.Close()
    writer := bufio.NewWriter(file)
    str := string(data)
    writer.WriteString(str)
    writer.WriteString("\n")
    writer.Flush()
    return true
}

//从文件中读取序列化后的monster，反序列化为monster对象
func (monster *Monster) ReStore() bool {
    //读取文件中的序列化后的monster
    filePath := "/Users/Tsunami/Documents/monster.txt"
    file, err := os.Open(filePath)
    //file, err := os.OpenFile(filePath, os.O_RDONLY, 0666)
    if err != nil {
        fmt.Printf("打开文件失败：%v", err)
        return false
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        data, err := reader.ReadString('\n')
        if err == io.EOF {
            break
        }
        fmt.Printf("文件中读取的序列化的monster为:%v\n", data)
        //将读取到的monster进行反序列化
        err = json.Unmarshal([]byte(data), monster)
        if err != nil {
            fmt.Printf("反序列化失败：%v", err)
            return false
        }
        fmt.Printf("反序列化后的monster为:%v\n", data)
    }
    return true
}

monster.go（ioutil方式）

package monster

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
)

type Monster1 struct {
    Name  string
    Age   int
    Skill string
}

//序列化monster变量后保存到文件中
func (monster *Monster1) Store1() bool {
    //输出结构体monster
    fmt.Printf("结构体为：%v\n", monster)
    //序列化monster
    data, err := json.Marshal(monster)
    if err != nil {
        fmt.Printf("序列化失败：%v", err)
        return false
    }
    fmt.Printf("序列化后的monster为：%v\n", string(data))
    //将序列化的monster存储到文件中
    filePath := "/Users/Tsunami/Documents/monster1.txt"
    err = ioutil.WriteFile(filePath, data, 0666)
    if err != nil {
        fmt.Printf("打开文件失败：%v", err)
        return false
    }
    return true
}

//从文件中读取序列化后的monster，反序列化为monster对象
func (monster *Monster1) ReStore1() bool {
    //读取文件中的序列化后的monster
    filePath := "/Users/Tsunami/Documents/monster1.txt"
    data, err := ioutil.ReadFile(filePath)
    if err != nil {
        fmt.Printf("打开文件失败：%v", err)
        return false
    }
    fmt.Printf("文件中读取的序列化的monster为:%v\n", string(data))
    //将读取到的monster进行反序列化
    err = json.Unmarshal([]byte(data), monster)
    if err != nil {
        fmt.Printf("反序列化失败：%v", err)
        return false
    }
    fmt.Printf("反序列化后的monster为:%v\n", string(data))
    return true
}

monster_test.go

package monster

import "testing"

func TestMonster_Store1(t *testing.T) {
    monster := Monster1{
        Name:  "红孩儿",
        Age:   10,
        Skill: "吐火",
    }
    res := monster.Store1()
    if !res {
        t.Fatalf("monster.Store()错误,希望为:%v,实际为:%v", true, res)
    }
    t.Logf("monster.Store()测试成功！")
}

func TestMonster_ReStore1(t *testing.T) {
    var monster = Monster1{}
    res := monster.ReStore1()
    if !res {
        t.Fatalf("monster.Restore()错误，希望为：%v,实际为：%v", true, res)
    }
    if monster.Name != "红孩儿" {
        t.Fatalf("monster.Restore()错误，希望为：%v,实际为：%v", "红孩儿", monster.Name)
    }
    t.Logf("monster.Store()测试成功")
}