test: optimize adaptor unit_tests

adaptor/handler_test.go

@@ -43,18 +43,50 @@ package adaptor
 
 import (
  "context"
+ "crypto/tls"
+ "github.com/cloudwego/hertz/pkg/app"
+ "github.com/cloudwego/hertz/pkg/app/client"
+ "github.com/cloudwego/hertz/pkg/common/adaptor"
+ "github.com/cloudwego/hertz/pkg/common/config"
+ "github.com/cloudwego/hertz/pkg/common/test/assert"
+ "github.com/cloudwego/hertz/pkg/network"
+ "github.com/cloudwego/hertz/pkg/network/netpoll"
+ "github.com/cloudwego/hertz/pkg/network/standard"
+ "github.com/cloudwego/hertz/pkg/protocol"
+ "github.com/cloudwego/hertz/pkg/protocol/consts"
+ "github.com/cloudwego/hertz/pkg/route"
  "io/ioutil"
+ "math/rand"
  "net/http"
  "net/url"
  "reflect"
+ "strings"
  "testing"
-
- "github.com/cloudwego/hertz/pkg/app"
- "github.com/cloudwego/hertz/pkg/common/test/assert"
- "github.com/cloudwego/hertz/pkg/protocol"
- "github.com/cloudwego/hertz/pkg/protocol/consts"
+ "time"
 )
 
+type mockDialer struct {
+ network.Dialer
+ customDialerFunc func(network, address string, timeout time.Duration, tlsConfig *tls.Config)
+ network string
+ address string
+ timeout time.Duration
+}
+
+func newMockDialerWithCustomFunc(network, address string, timeout time.Duration, f func(network, address string, timeout time.Duration, tlsConfig *tls.Config)) network.Dialer {
+ dialer := standard.NewDialer()
+ if rand.Intn(2) == 0 {
+ dialer = netpoll.NewDialer()
+ }
+ return &mockDialer{
+ Dialer: dialer,
+ customDialerFunc: f,
+ network: network,
+ address: address,
+ timeout: timeout,
+ }
+}
+
 func TestNewHertzHandler(t *testing.T) {
  t.Parallel()
 
@@ -139,3 +171,257 @@ func setContextValueMiddleware(next app.HandlerFunc, key string, value interface
  next(ctx, c)
  }
 }
+
+func TestConsumingBodyOnNextConn(t *testing.T) {
+ t.Parallel()
+
+ reqNum := 0
+ ch := make(chan *http.Request)
+ servech := make(chan error, 1)
+
+ opt := config.NewOptions([]config.Option{})
+ opt.Addr = "127.0.0.1:10025"
+ engine := route.NewEngine(opt)
+ handler := func(res http.ResponseWriter, req *http.Request) {
+ reqNum++
+ ch <- req
+ }
+
+ hertzHandler := NewHertzHTTPHandler(http.HandlerFunc(handler))
+
+ engine.POST("/", hertzHandler)
+ go engine.Run()
+ defer func() {
+ engine.Close()
+ }()
+ time.Sleep(time.Millisecond * 500)
+
+ c, _ := client.NewClient()
+
+ go func() {
+ req := protocol.AcquireRequest()
+ resp := protocol.AcquireResponse()
+ defer func() {
+ protocol.ReleaseRequest(req)
+ protocol.ReleaseResponse(resp)
+ }()
+ req.SetRequestURI("http://127.0.0.1:10025")
+ req.SetMethod("POST")
+ servech <- c.Do(context.Background(), req, resp)
+ servech <- c.Do(context.Background(), req, resp)
+ }()
+
+ var req *http.Request
+ req = <-ch
+ if req == nil {
+ t.Fatal("Got nil first request.")
+ }
+ if req.Method != "POST" {
+ t.Errorf("For request #1's method, got %q; expected %q",
+ req.Method, "POST")
+ }
+
+ req = <-ch
+ if req == nil {
+ t.Fatal("Got nil first request.")
+ }
+ if req.Method != "POST" {
+ t.Errorf("For request #2's method, got %q; expected %q",
+ req.Method, "POST")
+ }
+
+ if serveerr := <-servech; serveerr != nil {
+ t.Errorf("Serve returned %q; expected EOF", serveerr)
+ }
+}
+
+func TestCopyToHertzRequest(t *testing.T) {
+ req := http.Request{
+ Method: "GET",
+ RequestURI: "/test",
+ URL: &url.URL{
+ Scheme: "http",
+ Host: "test.com",
+ },
+ Proto: "HTTP/1.1",
+ Header: http.Header{},
+ }
+ req.Header.Set("key1", "value1")
+ req.Header.Add("key2", "value2")
+ req.Header.Add("key2", "value22")
+ hertzReq := protocol.Request{}
+ err := adaptor.CopyToHertzRequest(&req, &hertzReq)
+ assert.Nil(t, err)
+ assert.DeepEqual(t, req.Method, string(hertzReq.Method()))
+ assert.DeepEqual(t, req.RequestURI, string(hertzReq.Path()))
+ assert.DeepEqual(t, req.Proto, hertzReq.Header.GetProtocol())
+ assert.DeepEqual(t, req.Header.Get("key1"), hertzReq.Header.Get("key1"))
+ valueSlice := make([]string, 0, 2)
+ hertzReq.Header.VisitAllCustomHeader(func(key, value []byte) {
+ if strings.ToLower(string(key)) == "key2" {
+ valueSlice = append(valueSlice, string(value))
+ }
+ })
+
+ assert.DeepEqual(t, req.Header.Values("key2"), valueSlice)
+
+ assert.DeepEqual(t, 3, hertzReq.Header.Len())
+}
+
+func TestParseArgs(t *testing.T) {
+ t.Parallel()
+
+ opt := config.NewOptions([]config.Option{})
+ opt.Addr = "127.0.0.1:10026"
+ engine := route.NewEngine(opt)
+ handler := func(resp http.ResponseWriter, req *http.Request) {
+ queryParams := req.URL.Query()
+
+ paramValue := queryParams.Get("test")
+
+ assert.DeepEqual(t, paramValue, "test_value")
+ }
+
+ hertzHandler := NewHertzHTTPHandler(http.HandlerFunc(handler))
+
+ engine.GET("/", hertzHandler)
+ go engine.Run()
+ defer func() {
+ engine.Close()
+ }()
+ time.Sleep(time.Millisecond * 500)
+
+ c, _ := client.NewClient()
+
+ req := protocol.AcquireRequest()
+ resp := protocol.AcquireResponse()
+ defer func() {
+ protocol.ReleaseRequest(req)
+ protocol.ReleaseResponse(resp)
+ }()
+ req.SetRequestURI("http://127.0.0.1:10026/?test=test_value")
+ req.SetMethod("GET")
+
+ err := c.Do(context.Background(), req, resp)
+ assert.Nil(t, err)
+
+}
+
+func TestCookies(t *testing.T) {
+ t.Parallel()
+
+ opt := config.NewOptions([]config.Option{})
+ opt.Addr = "127.0.0.1:10027"
+ engine := route.NewEngine(opt)
+ handler := func(resp http.ResponseWriter, req *http.Request) {
+ //cookie1 := http.Cookie{
+ // Name: "myCookie1",
+ // Value: "cookieValue1",
+ // Expires: time.Now().Add(24 * time.Hour),
+ // HttpOnly: false,
+ // Secure: false,
+ //}
+ //
+ //cookie2 := http.Cookie{
+ // Name: "myCookie2",
+ // Value: "cookieValue2",
+ // Expires: time.Now().Add(24 * time.Hour),
+ // HttpOnly: true,
+ // Secure: true,
+ //}
+ //
+ //req.AddCookie(&cookie1)
+ //req.AddCookie(&cookie2)
+ //http.SetCookie(resp, &cookie1)
+ //http.SetCookie(resp, &cookie2)
+
+ c, err := req.Cookie("myCookie1")
+ assert.Nil(t, err)
+ assert.DeepEqual(t, c.Value, "cookieValue1")
+ assert.DeepEqual(t, c.HttpOnly, false)
+ assert.DeepEqual(t, c.Secure, false)
+
+ c, err = req.Cookie("myCookie2")
+ assert.Nil(t, err)
+ assert.DeepEqual(t, c.Value, "cookieValue2")
+
+ c.Secure = true
+ c.HttpOnly = true
+ c.Domain = "google.com"
+ c.Expires = time.Now().Add(24 * time.Hour)
+ http.SetCookie(resp, c)
+
+ assert.DeepEqual(t, c.HttpOnly, true)
+ assert.DeepEqual(t, c.Secure, true)
+ assert.DeepEqual(t, c.Domain, "google.com")
+ assert.NotEqual(t, c.Expires, nil)
+ }
+
+ hertzHandler := NewHertzHTTPHandler(http.HandlerFunc(handler))
+
+ engine.GET("/", hertzHandler)
+ go engine.Run()
+ defer func() {
+ engine.Close()
+ }()
+ time.Sleep(time.Millisecond * 500)
+
+ c, _ := client.NewClient()
+
+ req := protocol.AcquireRequest()
+ resp := protocol.AcquireResponse()
+ defer func() {
+ protocol.ReleaseRequest(req)
+ protocol.ReleaseResponse(resp)
+ }()
+ req.SetRequestURI("http://127.0.0.1:10027")
+ req.SetMethod("GET")
+ req.SetCookie("myCookie1", "cookieValue1")
+ req.SetCookie("myCookie2", "cookieValue2")
+
+ err := c.Do(context.Background(), req, resp)
+ assert.Nil(t, err)
+}
+
+func TestHeaders(t *testing.T) {
+ t.Parallel()
+
+ opt := config.NewOptions([]config.Option{})
+ opt.Addr = "127.0.0.1:10028"
+ engine := route.NewEngine(opt)
+ handler := func(resp http.ResponseWriter, req *http.Request) {
+ k := req.Header.Get("key1")
+ assert.DeepEqual(t, k, "value1")
+ c := req.Header.Get("cookie")
+ assert.DeepEqual(t, c, "cookie=cookie_value")
+ //assert.DeepEqual(t, req.ContentLength, 15) todo: fix this
+ }
+
+ hertzHandler := NewHertzHTTPHandler(http.HandlerFunc(handler))
+
+ engine.GET("/", hertzHandler)
+ go engine.Run()
+ defer func() {
+ engine.Close()
+ }()
+ time.Sleep(time.Millisecond * 500)
+
+ c, _ := client.NewClient()
+
+ req := protocol.AcquireRequest()
+ resp := protocol.AcquireResponse()
+ defer func() {
+ protocol.ReleaseRequest(req)
+ protocol.ReleaseResponse(resp)
+ }()
+ req.SetRequestURI("http://127.0.0.1:10028")
+ req.SetMethod("GET")
+ req.Header.Set("key1", "value1")
+ req.Header.SetCookie("cookie", "cookie_value")
+ req.Header.SetMethod("GET")
+ req.Header.InitContentLengthWithValue(14)
+ //req.Header.SetContentLength(15) todo: fix this
+
+ err := c.Do(context.Background(), req, resp)
+ assert.Nil(t, err)
+}

go.mod

@@ -1,8 +1,30 @@
 module github.com/hertz-contrib/pprof
 
-go 1.16
+go 1.19
 
 require (
- github.com/cloudwego/hertz v0.3.2
+ github.com/cloudwego/hertz v0.8.0
  github.com/felixge/fgprof v0.9.3
 )
+
+require (
+ github.com/bytedance/go-tagexpr/v2 v2.9.2 // indirect
+ github.com/bytedance/gopkg v0.0.0-20220413063733-65bf48ffb3a7 // indirect
+ github.com/bytedance/sonic v1.8.1 // indirect
+ github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+ github.com/cloudwego/netpoll v0.5.0 // indirect
+ github.com/fsnotify/fsnotify v1.5.4 // indirect
+ github.com/golang/protobuf v1.5.0 // indirect
+ github.com/google/pprof v0.0.0-20211214055906-6f57359322fd // indirect
+ github.com/henrylee2cn/ameda v1.4.10 // indirect
+ github.com/henrylee2cn/goutil v0.0.0-20210127050712-89660552f6f8 // indirect
+ github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+ github.com/nyaruka/phonenumbers v1.0.55 // indirect
+ github.com/tidwall/gjson v1.14.4 // indirect
+ github.com/tidwall/match v1.1.1 // indirect
+ github.com/tidwall/pretty v1.2.0 // indirect
+ github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+ golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect
+ golang.org/x/sys v0.0.0-20220412211240-33da011f77ad // indirect
+ google.golang.org/protobuf v1.27.1 // indirect
+)