学习单元测试，告别祈祷式编程

func Add(x, y int) int {
    return x + y
}

import "testing"

func TestAdd(t *testing.T) {
    // arrange 准备数据
    x, y := 1, 2
    // act   运行
    got := Add(x, y)
    //assert  断言
    if got != 3 {
        t.Errorf("Add() = %v, want %v", got, 3)
    }
}

package ut

import (
    "fmt"
    "strconv"
    "strings"
)

func isNumber(num string) (int, error) {
    num = strings.TrimSpace(num)
    n, err := strconv.Atoi(num)
    return n, err
}

func multiply(x string, y int) string {
    // 如果x 去除前后的空格后是数字，返回 数字的乘积
    //     比如 x="2" y=3 return "6"
    // 如果x 去除前后的空格后不是数字，则返回字符串的x的y倍
    //     比如 x="a" y=2 return "aa"
    num, err := isNumber(x)
    if err == nil {
        return fmt.Sprintf("%d", num*y)
    }
    result := ""
    for i := 0; i < y; i++ {
        result = fmt.Sprintf("%s%s", result, x)
    }
    return result
}

// 测试方法的名字不直观，并不能看出具体要测试什么
func Test_multiply(t *testing.T) {
    type args struct {
        x string
        y int
    }
    // 一个测试方法中有太多的测试用例
    tests := []struct {
        name string
        args args
        want string
    }{
        {
            "return nil",
            args{
                "",
                2,
            },
            "",
        },
        {
            "return 2",
            args{
                "1",
                2,
            },
            "2",
        },
        {// 测试数据有点奇葩，不直观
            "return aaa",
            args{
                "aaaaaaaaaa",
                6,
            },
            "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := multiply(tt.args.x, tt.args.y); got != tt.want {
               // 数据错误的时候有明确标明测试数据，期望结果和实际结果，这一点还是有用的
                t.Errorf("multiply() = %v, want %v", got, tt.want)
            }
        })
    }
}

// 测试特殊值 “空字符串”
func Test_multiply_empty_returnEmpty(t *testing.T) {
    // 用例简单，只包含输入、执行和判断
    x, y, want := "", 1, ""
    got := multiply(x, y)
    if got != want {
       // 有效的失败消息
        t.Errorf("multiply() = %v, want %v", got, want)
    }
}

// 测试包含空格的数字 边界值
func Test_multiply_numberWithSpace_returnNumber(t *testing.T) {
    x, y, want := " 2", 3, "6"
    got := multiply(x, y)
    if got != want {
        t.Errorf("multiply() = %v, want %v", got, want)
    }
}
// 测试正常数据
func Test_multiply_number_returnNumber(t *testing.T) {
    x, y, want := "2", 3, "6"
    got := multiply(x, y)
    if got != want {
        t.Errorf("multiply() = %v, want %v", got, want)
    }
}
// 测试非数字字符
func Test_multiply_String_returnString(t *testing.T) {
    // 输入简单的字符串就可以测试，没必要用太奇怪或者太长或者太大的数据数据
    x, y, want := "a", 3, "aaa"
    got := multiply(x, y)
    if got != want {
        t.Errorf("multiply() = %v, want %v", got, want)
    }
}
// 测试空格 边界值
func Test_multiply_space_returnSpace(t *testing.T) {
    x, y, want := " ", 3, "   "
    got := multiply(x, y)
    if got != want {
        t.Errorf("multiply() = %v, want %v", got, want)
    }
}

//auth.go
//假设我们有一个依赖http请求的鉴权接口
type AuthService interface{    
    Login(username string,password string) (token string,e error)   
    Logout(token string) error
}

//auth_test.go
type authService struct {}
func (auth *authService) Login (username string,password string) (string,error){
    return "token", nil
}
func (auth *authService) Logout(token string) error{    
    return nil
}

package ut

func notifyUser(username string){
    // 如果是管理员，发送登录提醒邮件
}

type AuthService struct{}

func (auth *AuthService) Login(username string, password string) (string, error) {
    notifyUser(username)
    return "token", nil
}
func (auth *AuthService) Logout(token string) error {
    return nil
}