Golang Testing 概览 - 深入篇

package yy_test
func TestOne(t *testing.T) {  if yy.Factorial(3) != 6 {    t.Fatal("bad")  }}

package yy
func TestTwo(t *testing.T) {  if factorial(1, 3) != 6 {    t.Fatal("bad")  }}

package yy
func ExportedFactorial(accumulator, val int) int {  return factorial(accumulator, val)}

package yy_test
func TestThree(t *testing.T) {  if ExportedFactorial(1, 3) != 6 {    t.Fatal("bad")  }}

func TestMain(m *testing.M) {  // setup codes ...
  // call flag.Parse() here if TestMain uses flags    exitCode := m.Run()    // tear-down codes ...    os.Exit(exitCode)}

func TestFoo(t *testing.T) {    // <setup code>    t.Run("A=1", func(t *testing.T) { ... })    t.Run("A=2", func(t *testing.T) { ... })    t.Run("B=1", func(t *testing.T) { ... })    // <tear-down code>}

$ go test -run ''      # 执行所有测试。$ go test -run Foo     # 执行匹配 "Foo" 的顶层测试，例如 "TestFooBar"。$ go test -run Foo/A=  # 对于匹配 "Foo" 的顶层测试，且其匹配 "A=" 的子测试。$ go test -run /A=1    # 执行所有匹配 "A=1" 的子测试。

func TestGroupedParallel(t *testing.T) {    for _, tc := range tests {        tc := tc // capture range variable        t.Run(tc.Name, func(t *testing.T) {            t.Parallel()            ...        })    }}
func TestTeardownParallel(t *testing.T) {    // This Run will not return until the parallel tests finish.    t.Run("group", func(t *testing.T) {        t.Run("Test1", parallelTest1)        t.Run("Test2", parallelTest2)        t.Run("Test3", parallelTest3)    })    // <tear-down code>}

func SeedLists(dbc *sqlx.DB) ([]list.List, error) {    now := time.Now().Truncate(time.Microsecond)
    lists := []list.List{        {            Name:     "Grocery",            Created:  now,            Modified: now,        },        {            Name:     "To-do",            Created:  now,            Modified: now,        },        {            Name:     "Employees",            Created:  now,            Modified: now,        },    }
    for i := range lists {        stmt, err := dbc.Prepare("INSERT INTO list (name, created, modified) VALUES ($1, $2, $3) RETURNING list_id;")        if err != nil {            return nil, errors.Wrap(err, "prepare list insertion")        }
        row := stmt.QueryRow(lists[i].Name, lists[i].Created, lists[i].Modified)
        if err = row.Scan(&lists[i].ID); err != nil {            if err := stmt.Close(); err != nil {                return nil, errors.Wrap(err, "close psql statement")            }
            return nil, errors.Wrap(err, "capture list id")        }
        if err := stmt.Close(); err != nil {            return nil, errors.Wrap(err, "close psql statement")        }    }
    return lists, nil}

func SeedItems(dbc *sqlx.DB, lists []list.List) ([]item.Item, error) {    now := time.Now().Truncate(time.Microsecond)
    items := []item.Item{        {            ListID:   lists[0].ID, // Grocery            Name:     "Chocolate Milk",            Quantity: 1,            Created:  now,            Modified: now,        },        {            ListID:   lists[0].ID, // Grocery            Name:     "Mac and Cheese",            Quantity: 2,            Created:  now,            Modified: now,        },        {            ListID:   lists[1].ID, // To-do            Name:     "Write Integration Tests",            Quantity: 1,            Created:  now,            Modified: now,        },    }
    for i := range items {        stmt, err := dbc.Prepare("INSERT INTO item (list_id, name, quantity, created, modified) VALUES ($1, $2, $3, $4, $5) RETURNING item_id;")        if err != nil {            return nil, errors.Wrap(err, "prepare item insertion")        }
        row := stmt.QueryRow(items[i].ListID, items[i].Name, items[i].Quantity, items[i].Created, items[i].Modified)
        if err = row.Scan(&items[i].ID); err != nil {            if err := stmt.Close(); err != nil {                return nil, errors.Wrap(err, "close psql statement")            }
            return nil, errors.Wrap(err, "capture list id")        }
        if err := stmt.Close(); err != nil {            return nil, errors.Wrap(err, "close psql statement")        }    }
    return items, nil}

func Truncate(dbc *sqlx.DB) error {    stmt := "TRUNCATE TABLE list, item;"
    if _, err := dbc.Exec(stmt); err != nil {        return errors.Wrap(err, "truncate test database tables")    }
    return nil}

package mytest
import (  "testing"    "database/sql"
  seedsql "github.com/nguyendangminh/seed/sql"    _ "github.com/go-sql-driver/mysql"  "github.com/stretchr/testify/assert")
func InitMySQLDB() (*sql.DB, error) {    return db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/dbname?multiStatements=true")}
func TestDatabaseIntegration(t *testing.T) {  db, err := InitMySQLDB()  defer db.Close()
  // Seeding  err = seedsql.SeedByFile(db, "/path/to/seed-file.sql")  assert.NoError(t, err)
  // Your other tests belows
    seedsql.CleanByFile(db, "/path/to/cleanup-file.sql")}

// handlers.gopackage handlers
// e.g. http.HandleFunc("/health-check", HealthCheckHandler)func HealthCheckHandler(w http.ResponseWriter, r *http.Request) {    // A very simple health check.    w.WriteHeader(http.StatusOK)    w.Header().Set("Content-Type", "application/json")
    // In the future we could report back on the status of     // our DB, or our cache (e.g. Redis) by performing a     // simple PING, and include them in the response.    io.WriteString(w, `{"alive": true}`)}
// main.gopackage main
import (  "fmt"  "github.com/hedzr/pools/ww/handlers"  "log"  "net/http")
func main() {  http.Handle("/", &indexHandler{content: "hello world!"})  http.HandleFunc("/health-check", handlers.HealthCheckHandler)  log.Fatal(http.ListenAndServe(":8111", nil))}
type indexHandler struct {  content string}
func (ih *indexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {  _, _ = fmt.Fprintf(w, ih.content)}

// handlers_test.gopackage handlers
import (    "net/http"    "net/http/httptest"    "testing")
func TestHealthCheckHandler(t *testing.T) {    // Create a request to pass to our handler. We don't have any query parameters for now, so we'll    // pass 'nil' as the third parameter.    req, err := http.NewRequest("GET", "/health-check", nil)    if err != nil {        t.Fatal(err)    }
    // We create a ResponseRecorder (which satisfies http.ResponseWriter) to record the response.    rr := httptest.NewRecorder()    handler := http.HandlerFunc(HealthCheckHandler)
    // Our handlers satisfy http.Handler, so we can call their ServeHTTP method     // directly and pass in our Request and ResponseRecorder.    handler.ServeHTTP(rr, req)
    // Check the status code is what we expect.    if status := rr.Code; status != http.StatusOK {        t.Errorf("handler returned wrong status code: got %v want %v",            status, http.StatusOK)    }
    // Check the response body is what we expect.    expected := `{"alive": true}`    if rr.Body.String() != expected {        t.Errorf("handler returned unexpected body: got %v want %v",            rr.Body.String(), expected)    }}

func BenchmarkXxx(*testing.B)

func BenchmarkRandInt(b *testing.B) {    for i := 0; i < b.N; i++ {        rand.Int()    }}

❯ go test -v -test.run '^Bench.*$' -test.bench '^Bench.*$' ./yy/goos: darwingoarch: amd64pkg: github.com/hedzr/pools/yyBenchmarkRandIntBenchmarkRandInt-16     81169230                14.7 ns/opPASSok      github.com/hedzr/pools/yy       2.198s

func BenchmarkBigLen(b *testing.B) {    big := NewBig()    b.ResetTimer()    for i := 0; i < b.N; i++ {        big.Len()    }}

func BenchmarkTemplateParallel(b *testing.B) {    templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))    b.RunParallel(func(pb *testing.PB) {        var buf bytes.Buffer        for pb.Next() {            buf.Reset()            templ.Execute(&buf, "World")        }    })}