go test 测试用例那些事

func TestXXXXXXX(t *testing.T)
func BenchXXXXXX(b *testing.B)
func TestMain(m *testing.M)

type T struct {
    common
    isParallel bool
    context    *testContext // For running tests and subtests.
}

type B struct {
    common
    importPath       string // import path of the package containing the benchmark
    context          *benchContext
    N                int
    previousN        int           // number of iterations in the previous run
    previousDuration time.Duration // total duration of the previous run
    benchFunc        func(b *B)
    benchTime        time.Duration
    bytes            int64
    missingBytes     bool // one of the subbenchmarks does not have bytes set.
    timerOn          bool
    showAllocResult  bool
    result           BenchmarkResult
    parallelism      int // RunParallel creates parallelism*GOMAXPROCS goroutines
    // The initial states of memStats.Mallocs and memStats.TotalAlloc.
    startAllocs uint64
    startBytes  uint64
    // The net total of this test after being run.
    netAllocs uint64
    netBytes  uint64
}

// M is a type passed to a TestMain function to run the actual tests.
type M struct {
    deps       testDeps
    tests      []InternalTest
    benchmarks []InternalBenchmark
    examples   []InternalExample

    timer     *time.Timer
    afterOnce sync.Once

    numRun int
}

func TestNewUserInfo(t *testing.T) {
    u := NewUserInfo()
    if len(u.Name) == 0 {
        t.Error("name is empty")
    }
}

go test -v -run="(?i)user"

go test -v -run=TestGetOrderList
go test -v -run="TestGetOrderList|TestNewUserInfo"

go test -v user_test.go  user.go

go test -v

go test -v ./...

go test -bench="."

func BenchmarkUserInfoList(b *testing.B) {
    b.StopTimer()
    // do something
    b.StartTimer()
    for i := 0; i < b.N; i++ {
        // pretend delay
        //time.Sleep(time.Millisecond * 500)
        userInfoList := UserInfoList()
        if len(userInfoList) != 10 {
            b.Error("userInfoList is empty")
        }
    }
}

go test -bench="." -cpu=3 -benchtime=5s

go help testflag

func TestMain(m *testing.M) {
    os.Setenv(config.ENV_STR, config.ENV_DEV)
    config.LoadConfig()
    fmt.Printf("Env is %s\n", os.Getenv(config.ENV_STR))
    fmt.Printf("config info %#v\n", config.ConfigInfo)

    // do something... eg: init data
    // ...

    os.Exit(m.Run())
}

 go test -v -coverprofile cover.out user_test.go user.go
go tool cover -html=cover.out -o cover.html 

func HandleNewUser(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    fmt.Printf("url parameter user name is %s\n", name)

    say := r.FormValue("say")
    fmt.Printf("req say:' %s '\n", say)
    newUser := NewUserInfo()
    jData, _ := json.Marshal(newUser)
    w.WriteHeader(http.StatusOK)
    w.Header().Set("Content-Type", "application/json")
    w.Write(jData)
}

func TestHandleNewUser(t *testing.T) {
    postBody := url.Values{}
    postBody.Add("say", "hello world")
    req := httptest.NewRequest(http.MethodPost, "http://localhost/createuser?name=linus", strings.NewReader(postBody.Encode()))
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    w := httptest.NewRecorder()
    HandleNewUser(w, req)

    if w.Code != http.StatusOK {
        t.Error("new user api error")
    }
    if w.Body.Len() == 0 {
        t.Error(" response is empty")
    }
    user := &model.UserInfo{}
    err := json.Unmarshal(w.Body.Bytes(), user)
    if err != nil {
        t.Error("response data error")
    }
    t.Logf("create user api response : %#v", user)
}

func TestNewUserInfo(t *testing.T) {
    a := assert.New(t)

    router := gin.New()
    const path = "/newUserInfo"
    router.POST(path, NewUserInfo)

    body := url.Values{}
    body.Set("say", "hello world")
    rr, err := testutils.PostFormRequst(path + "?name=lp", router, body)
    a.Nil(err)

    user := &model.UserInfo{}
    err = json.Unmarshal(rr.Body.Bytes(), user)
    a.Nil(err)
    a.NotEqual(user.Name, "")
    a.NotEqual(user.Age, 0)
    t.Logf("%#v\n", user)
}

github.com/stretchr/testify
github.com/jarcoal/httpmock

    a.Nil(err)
    a.NotEqual(user.Name, "")
    a.NotEqual(user.Age, 0)

func TestUserRoleList(t *testing.T) {
    a := assert.New(t)
    // mock http
    testutils.HttpMockActivateNonDefault()
    httpmock.RegisterNoResponder(
        httpmock.NewStringResponder(http.StatusOK, fmt.Sprintf(`
        [
          {
            "id": 1,
            "name": "a"
          },
          {
            "id": 2,
            "name": "b"
          },
          {
            "id": 3,
            "name": "c"
          }
        ]
    `)))
    defer httpmock.DeactivateAndReset()

    router := gin.New()
    const path = "/userRoleList"
    router.GET(path, UserRoleList)
    rr, err := testutils.GetRequst(path, router)
    a.Nil(err)
    a.Equal(rr.Result().StatusCode, http.StatusOK)

    roles := make([]model.UserRole, 0)
    err = json.Unmarshal(rr.Body.Bytes(), &roles)
    a.Nil(err)
    a.NotEqual(len(roles), 0)
    t.Logf("len of roles: %d\n", len(roles))
}