server/beego
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

httplib: fix unstable test, do not use httplib.org

Browse Source
This commit is contained in:
Deng Ming
2023-06-04 14:26:53 +08:00
parent 4f4cf565f0
commit 3e96b23551
86 changed files with 1166 additions and 917 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
client/httplib/httpclient.go
View File

@@ -17,7 +17,6 @@ package httplib
import (
"bytes"
"io"
"io/ioutil"
"net/http"
)
@@ -105,7 +104,7 @@ func (c *Client) handleCarrier(value interface{}, req *BeegoHTTPRequest) error {
if err != nil {
return err
}
req.resp.Body = ioutil.NopCloser(bytes.NewReader(b))
req.resp.Body = io.NopCloser(bytes.NewReader(b))
carrier.SetHTTPResponse(req.resp)
}
if carrier, ok := value.(HTTPBodyCarrier); ok {
@@ -113,7 +112,7 @@ func (c *Client) handleCarrier(value interface{}, req *BeegoHTTPRequest) error {
if err != nil {
return err
}
reader := ioutil.NopCloser(bytes.NewReader(b))
reader := io.NopCloser(bytes.NewReader(b))
carrier.SetReader(reader)
}
if carrier, ok := value.(HTTPBytesCarrier); ok {

272
client/httplib/httpclient_test.go
View File

@@ -15,12 +15,17 @@
package httplib
import (
"encoding/json"
"encoding/xml"
"io"
"io/ioutil"
"net"
"net/http"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"gopkg.in/yaml.v3"
"github.com/stretchr/testify/assert"
)
@@ -32,13 +37,13 @@ func TestNewClient(t *testing.T) {
}
type slideShowResponse struct {
Resp *http.Response
bytes []byte
StatusCode int
Body io.ReadCloser
Header map[string][]string
Resp *http.Response `json:"resp,omitempty"`
bytes []byte `json:"bytes,omitempty"`
StatusCode int `json:"status_code,omitempty"`
Body io.ReadCloser `json:"body,omitempty"`
Header map[string][]string `json:"header,omitempty"`
Slideshow slideshow `json:"slideshow" yaml:"slideshow"`
Slideshow slideshow `json:"slideshow,omitempty" yaml:"slideshow" xml:"slideshow"`
}
func (r *slideShowResponse) SetHTTPResponse(resp *http.Response) {
@@ -66,7 +71,7 @@ func (r *slideShowResponse) String() string {
}
type slideshow struct {
XMLName xml.Name `xml:"slideshow"`
//XMLName xml.Name `xml:"slideshow"`
Title string `json:"title" yaml:"title" xml:"title,attr"`
Author string `json:"author" yaml:"author" xml:"author,attr"`
@@ -80,63 +85,122 @@ type slide struct {
Title string `json:"title" yaml:"title" xml:"title"`
}
func TestClientHandleCarrier(t *testing.T) {
v := "beego"
client, err := NewClient("test", "http://httpbin.org/",
WithUserAgent(v))
if err != nil {
t.Fatal(err)
}
s := &slideShowResponse{}
err = client.Get(s, "/json")
if err != nil {
t.Fatal(err)
}
defer s.Body.Close()
assert.NotNil(t, s.Resp)
assert.NotNil(t, s.Body)
assert.Equal(t, "429", s.Header["Content-Length"][0])
assert.Equal(t, 200, s.StatusCode)
b, err := ioutil.ReadAll(s.Body)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, 429, len(b))
assert.Equal(t, s.String(), string(b))
type ClientTestSuite struct {
suite.Suite
l net.Listener
}
func TestClientGet(t *testing.T) {
client, err := NewClient("test", "http://httpbin.org/")
func (c *ClientTestSuite) SetupSuite() {
listener, err := net.Listen("tcp", ":8080")
require.NoError(c.T(), err)
c.l = listener
handler := http.NewServeMux()
handler.HandleFunc("/json", func(writer http.ResponseWriter, request *http.Request) {
data, _ := json.Marshal(slideshow{})
_, _ = writer.Write(data)
})
ssr := slideShowResponse{
Slideshow: slideshow{
Title: "Sample Slide Show",
Slides: []slide{
{
Title: "Content",
},
{
Title: "Overview",
},
},
},
}
handler.HandleFunc("/req2resp", func(writer http.ResponseWriter, request *http.Request) {
data, _ := io.ReadAll(request.Body)
_, _ = writer.Write(data)
})
handler.HandleFunc("/get", func(writer http.ResponseWriter, request *http.Request) {
data, _ := json.Marshal(ssr)
_, _ = writer.Write(data)
})
handler.HandleFunc("/get/xml", func(writer http.ResponseWriter, request *http.Request) {
data, err := xml.Marshal(ssr.Slideshow)
require.NoError(c.T(), err)
_, _ = writer.Write(data)
})
handler.HandleFunc("/get/yaml", func(writer http.ResponseWriter, request *http.Request) {
data, _ := yaml.Marshal(ssr)
_, _ = writer.Write(data)
})
go func() {
_ = http.Serve(listener, handler)
}()
}
func (c *ClientTestSuite) TearDownSuite() {
_ = c.l.Close()
}
func TestClient(t *testing.T) {
suite.Run(t, &ClientTestSuite{})
}
func (c *ClientTestSuite) TestClientHandleCarrier() {
t := c.T()
v := "beego"
client, err := NewClient("test", "http://localhost:8080/",
WithUserAgent(v))
require.NoError(t, err)
resp := &slideShowResponse{}
err = client.Get(resp, "/json")
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
assert.NotNil(t, resp.Resp)
assert.NotNil(t, resp.Body)
assert.Equal(t, "48", resp.Header["Content-Length"][0])
assert.Equal(t, 200, resp.StatusCode)
b, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, 48, len(b))
assert.Equal(t, resp.String(), string(b))
}
func (c *ClientTestSuite) TestClientGet() {
t := c.T()
client, err := NewClient("test", "http://localhost:8080/")
if err != nil {
t.Fatal(err)
}
// json
var s *slideShowResponse
err = client.Get(&s, "/json")
if err != nil {
t.Fatal(err)
}
var s slideShowResponse
err = client.Get(&s, "/get")
require.NoError(t, err)
assert.Equal(t, "Sample Slide Show", s.Slideshow.Title)
assert.Equal(t, 2, len(s.Slideshow.Slides))
assert.Equal(t, "Overview", s.Slideshow.Slides[1].Title)
// xml
var ssp *slideshow
err = client.Get(&ssp, "/base64/PD94bWwgPz48c2xpZGVzaG93CnRpdGxlPSJTYW1wbGUgU2xpZGUgU2hvdyIKZGF0ZT0iRGF0ZSBvZiBwdWJsaWNhdGlvbiIKYXV0aG9yPSJZb3VycyBUcnVseSI+PHNsaWRlIHR5cGU9ImFsbCI+PHRpdGxlPldha2UgdXAgdG8gV29uZGVyV2lkZ2V0cyE8L3RpdGxlPjwvc2xpZGU+PHNsaWRlIHR5cGU9ImFsbCI+PHRpdGxlPk92ZXJ2aWV3PC90aXRsZT48aXRlbT5XaHkgPGVtPldvbmRlcldpZGdldHM8L2VtPiBhcmUgZ3JlYXQ8L2l0ZW0+PGl0ZW0vPjxpdGVtPldobyA8ZW0+YnV5czwvZW0+IFdvbmRlcldpZGdldHM8L2l0ZW0+PC9zbGlkZT48L3NsaWRlc2hvdz4=")
if err != nil {
t.Fatal(err)
}
assert.Equal(t, "Sample Slide Show", ssp.Title)
assert.Equal(t, 2, len(ssp.Slides))
assert.Equal(t, "Overview", ssp.Slides[1].Title)
var ss slideshow
err = client.Get(&ss, "/get/xml")
require.NoError(t, err)
assert.Equal(t, "Sample Slide Show", ss.Title)
assert.Equal(t, 2, len(ss.Slides))
assert.Equal(t, "Overview", ss.Slides[1].Title)
// yaml
s = nil
err = client.Get(&s, "/base64/c2xpZGVzaG93OgogIGF1dGhvcjogWW91cnMgVHJ1bHkKICBkYXRlOiBkYXRlIG9mIHB1YmxpY2F0aW9uCiAgc2xpZGVzOgogIC0gdGl0bGU6IFdha2UgdXAgdG8gV29uZGVyV2lkZ2V0cyEKICAgIHR5cGU6IGFsbAogIC0gaXRlbXM6CiAgICAtIFdoeSA8ZW0+V29uZGVyV2lkZ2V0czwvZW0+IGFyZSBncmVhdAogICAgLSBXaG8gPGVtPmJ1eXM8L2VtPiBXb25kZXJXaWRnZXRzCiAgICB0aXRsZTogT3ZlcnZpZXcKICAgIHR5cGU6IGFsbAogIHRpdGxlOiBTYW1wbGUgU2xpZGUgU2hvdw==")
s = slideShowResponse{}
err = client.Get(&s, "/get/yaml")
if err != nil {
t.Fatal(err)
}
@@ -145,72 +209,82 @@ func TestClientGet(t *testing.T) {
assert.Equal(t, "Overview", s.Slideshow.Slides[1].Title)
}
func TestClientPost(t *testing.T) {
client, err := NewClient("test", "http://httpbin.org")
if err != nil {
t.Fatal(err)
func (c *ClientTestSuite) TestClientPost() {
t := c.T()
client, err := NewClient("test", "http://localhost:8080")
require.NoError(t, err)
input := slideShowResponse{
Slideshow: slideshow{
Title: "Sample Slide Show",
Slides: []slide{
{
Title: "Content",
},
{
Title: "Overview",
},
},
},
}
resp := &slideShowResponse{}
err = client.Get(resp, "/json")
if err != nil {
t.Fatal(err)
}
jsonStr := resp.String()
err = client.Post(resp, "/post", jsonStr)
if err != nil {
t.Fatal(err)
}
assert.NotNil(t, resp)
jsonStr, err := json.Marshal(input)
require.NoError(t, err)
resp := slideShowResponse{}
err = client.Post(&resp, "/req2resp", jsonStr)
require.NoError(t, err)
assert.Equal(t, input.Slideshow, resp.Slideshow)
assert.Equal(t, http.MethodPost, resp.Resp.Request.Method)
}
func TestClientPut(t *testing.T) {
client, err := NewClient("test", "http://httpbin.org")
if err != nil {
t.Fatal(err)
func (c *ClientTestSuite) TestClientPut() {
t := c.T()
client, err := NewClient("test", "http://localhost:8080")
require.NoError(t, err)
input := slideShowResponse{
Slideshow: slideshow{
Title: "Sample Slide Show",
Slides: []slide{
{
Title: "Content",
},
{
Title: "Overview",
},
},
},
}
resp := &slideShowResponse{}
err = client.Get(resp, "/json")
if err != nil {
t.Fatal(err)
}
jsonStr := resp.String()
err = client.Put(resp, "/put", jsonStr)
if err != nil {
t.Fatal(err)
}
assert.NotNil(t, resp)
jsonStr, err := json.Marshal(input)
require.NoError(t, err)
resp := slideShowResponse{}
err = client.Put(&resp, "/req2resp", jsonStr)
require.NoError(t, err)
assert.Equal(t, input.Slideshow, resp.Slideshow)
assert.Equal(t, http.MethodPut, resp.Resp.Request.Method)
}
func TestClientDelete(t *testing.T) {
client, err := NewClient("test", "http://httpbin.org")
if err != nil {
t.Fatal(err)
}
func (c *ClientTestSuite) TestClientDelete() {
t := c.T()
client, err := NewClient("test", "http://localhost:8080")
require.NoError(t, err)
resp := &slideShowResponse{}
err = client.Delete(resp, "/delete")
if err != nil {
t.Fatal(err)
}
err = client.Delete(resp, "/req2resp")
require.NoError(t, err)
defer resp.Resp.Body.Close()
assert.NotNil(t, resp)
assert.Equal(t, http.MethodDelete, resp.Resp.Request.Method)
}
func TestClientHead(t *testing.T) {
client, err := NewClient("test", "http://beego.gocn.vip")
if err != nil {
t.Fatal(err)
}
func (c *ClientTestSuite) TestClientHead() {
t := c.T()
client, err := NewClient("test", "http://localhost:8080")
require.NoError(t, err)
resp := &slideShowResponse{}
err = client.Head(resp, "")
err = client.Head(resp, "/req2resp")
if err != nil {
t.Fatal(err)
}

11
client/httplib/httplib.go
View File

@@ -27,7 +27,6 @@
// t.Fatal(err)
// }
// fmt.Println(str)
//
package httplib
import (
@@ -225,9 +224,9 @@ func (b *BeegoHTTPRequest) SetTransport(transport http.RoundTripper) *BeegoHTTPR
// example:
//
// func(req *http.Request) (*url.URL, error) {
// u, _ := url.ParseRequestURI("http://127.0.0.1:8118")
// return u, nil
// }
// u, _ := url.ParseRequestURI("http://127.0.0.1:8118")
// return u, nil
// }
func (b *BeegoHTTPRequest) SetProxy(proxy func(*http.Request) (*url.URL, error)) *BeegoHTTPRequest {
b.setting.Proxy = proxy
return b
@@ -592,10 +591,10 @@ func (b *BeegoHTTPRequest) Bytes() ([]byte, error) {
if err != nil {
return nil, berror.Wrap(err, ReadGzipBodyFailed, "building gzip reader failed")
}
b.body, err = ioutil.ReadAll(reader)
b.body, err = io.ReadAll(reader)
return b.body, berror.Wrap(err, ReadGzipBodyFailed, "reading gzip data failed")
}
b.body, err = ioutil.ReadAll(resp.Body)
b.body, err = io.ReadAll(resp.Body)
return b.body, err
}

310
client/httplib/httplib_test.go
View File

@@ -17,9 +17,10 @@ package httplib
import (
"bytes"
"context"
json "encoding/json"
"errors"
"fmt"
"io/ioutil"
"io"
"net"
"net/http"
"os"
@@ -27,19 +28,104 @@ import (
"testing"
"time"
"github.com/stretchr/testify/suite"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestResponse(t *testing.T) {
req := Get("http://httpbin.org/get")
resp, err := req.Response()
require.NoError(t, err)
t.Log(resp)
type HttplibTestSuite struct {
suite.Suite
l net.Listener
}
func TestDoRequest(t *testing.T) {
req := Get("https://goolnk.com/33BD2j")
func (h *HttplibTestSuite) SetupSuite() {
listener, err := net.Listen("tcp", ":8080")
require.NoError(h.T(), err)
h.l = listener
handler := http.NewServeMux()
handler.HandleFunc("/get", func(writer http.ResponseWriter, request *http.Request) {
agent := request.Header.Get("User-Agent")
_, _ = writer.Write([]byte("hello, " + agent))
})
handler.HandleFunc("/put", func(writer http.ResponseWriter, request *http.Request) {
_, _ = writer.Write([]byte("hello, put"))
})
handler.HandleFunc("/post", func(writer http.ResponseWriter, request *http.Request) {
body, _ := io.ReadAll(request.Body)
_, _ = writer.Write(body)
})
handler.HandleFunc("/delete", func(writer http.ResponseWriter, request *http.Request) {
_, _ = writer.Write([]byte("hello, delete"))
})
handler.HandleFunc("/cookies/set", func(writer http.ResponseWriter, request *http.Request) {
k1 := request.URL.Query().Get("k1")
http.SetCookie(writer, &http.Cookie{
Name: "k1",
Value: k1,
})
_, _ = writer.Write([]byte("hello, set cookie"))
})
handler.HandleFunc("/cookies", func(writer http.ResponseWriter, request *http.Request) {
body := request.Cookies()[0].String()
_, _ = writer.Write([]byte(body))
})
handler.HandleFunc("/basic-auth/user/passwd", func(writer http.ResponseWriter, request *http.Request) {
_, _, ok := request.BasicAuth()
if ok {
_, _ = writer.Write([]byte("authenticated"))
} else {
_, _ = writer.Write([]byte("no auth"))
}
})
handler.HandleFunc("/headers", func(writer http.ResponseWriter, request *http.Request) {
agent := request.Header.Get("User-Agent")
_, _ = writer.Write([]byte(agent))
})
handler.HandleFunc("/ip", func(writer http.ResponseWriter, request *http.Request) {
data := map[string]string{"origin": "127.0.0.1"}
jsonBytes, _ := json.Marshal(data)
_, _ = writer.Write(jsonBytes)
})
handler.HandleFunc("/redirect", func(writer http.ResponseWriter, request *http.Request) {
http.Redirect(writer, request, "redirect_dst", http.StatusTemporaryRedirect)
})
handler.HandleFunc("redirect_dst", func(writer http.ResponseWriter, request *http.Request) {
_, _ = writer.Write([]byte("hello"))
})
go func() {
_ = http.Serve(listener, handler)
}()
}
func (h *HttplibTestSuite) TearDownSuite() {
_ = h.l.Close()
}
func TestHttplib(t *testing.T) {
suite.Run(t, &HttplibTestSuite{})
}
func (h *HttplibTestSuite) TestResponse() {
req := Get("http://localhost:8080/get")
_, err := req.Response()
require.NoError(h.T(), err)
}
func (h *HttplibTestSuite) TestDoRequest() {
t := h.T()
req := Get("http://localhost:8080/redirect")
retryAmount := 1
req.Retries(1)
req.RetryDelay(1400 * time.Millisecond)
@@ -63,107 +149,79 @@ func TestDoRequest(t *testing.T) {
}
}
func TestGet(t *testing.T) {
req := Get("http://httpbin.org/get")
func (h *HttplibTestSuite) TestGet() {
t := h.T()
req := Get("http://localhost:8080/get")
b, err := req.Bytes()
require.NoError(t, err)
t.Log(b)
s, err := req.String()
require.NoError(t, err)
t.Log(s)
require.Equal(t, string(b), s)
}
func TestSimplePost(t *testing.T) {
func (h *HttplibTestSuite) TestSimplePost() {
t := h.T()
v := "smallfish"
req := Post("http://httpbin.org/post")
req := Post("http://localhost:8080/post")
req.Param("username", v)
str, err := req.String()
require.NoError(t, err)
t.Log(str)
n := strings.Index(str, v)
require.NotEqual(t, -1, n)
}
func (h *HttplibTestSuite) TestSimplePut() {
t := h.T()
_, err := Put("http://localhost:8080/put").String()
require.NoError(t, err)
}
func (h *HttplibTestSuite) TestSimpleDelete() {
t := h.T()
_, err := Delete("http://localhost:8080/delete").String()
require.NoError(t, err)
}
func (h *HttplibTestSuite) TestSimpleDeleteParam() {
t := h.T()
_, err := Delete("http://localhost:8080/delete").Param("key", "val").String()
require.NoError(t, err)
}
func (h *HttplibTestSuite) TestWithCookie() {
t := h.T()
v := "smallfish"
_, err := Get("http://localhost:8080/cookies/set?k1=" + v).SetEnableCookie(true).String()
require.NoError(t, err)
str, err := Get("http://localhost:8080/cookies").SetEnableCookie(true).String()
require.NoError(t, err)
n := strings.Index(str, v)
require.NotEqual(t, -1, n)
}
// func TestPostFile(t *testing.T) {
// v := "smallfish"
// req := Post("http://httpbin.org/post")
// req.Debug(true)
// req.Param("username", v)
// req.PostFile("uploadfile", "httplib_test.go")
// str, err := req.String()
// if err != nil {
// t.Fatal(err)
// }
// t.Log(str)
// n := strings.Index(str, v)
// if n == -1 {
// t.Fatal(v + " not found in post")
// }
// }
func TestSimplePut(t *testing.T) {
str, err := Put("http://httpbin.org/put").String()
func (h *HttplibTestSuite) TestWithBasicAuth() {
t := h.T()
str, err := Get("http://localhost:8080/basic-auth/user/passwd").SetBasicAuth("user", "passwd").String()
require.NoError(t, err)
t.Log(str)
}
func TestSimpleDelete(t *testing.T) {
str, err := Delete("http://httpbin.org/delete").String()
require.NoError(t, err)
t.Log(str)
}
func TestSimpleDeleteParam(t *testing.T) {
str, err := Delete("http://httpbin.org/delete").Param("key", "val").String()
require.NoError(t, err)
t.Log(str)
}
func TestWithCookie(t *testing.T) {
v := "smallfish"
str, err := Get("http://httpbin.org/cookies/set?k1=" + v).SetEnableCookie(true).String()
require.NoError(t, err)
t.Log(str)
str, err = Get("http://httpbin.org/cookies").SetEnableCookie(true).String()
require.NoError(t, err)
t.Log(str)
n := strings.Index(str, v)
if n == -1 {
t.Fatal(v + " not found in cookie")
}
}
func TestWithBasicAuth(t *testing.T) {
str, err := Get("http://httpbin.org/basic-auth/user/passwd").SetBasicAuth("user", "passwd").String()
require.NoError(t, err)
t.Log(str)
n := strings.Index(str, "authenticated")
if n == -1 {
t.Fatal("authenticated not found in response")
}
require.NotEqual(t, -1, n)
}
func TestWithUserAgent(t *testing.T) {
func (h *HttplibTestSuite) TestWithUserAgent() {
t := h.T()
v := "beego"
str, err := Get("http://httpbin.org/headers").SetUserAgent(v).String()
str, err := Get("http://localhost:8080/headers").SetUserAgent(v).String()
require.NoError(t, err)
t.Log(str)
n := strings.Index(str, v)
if n == -1 {
t.Fatal(v + " not found in user-agent")
}
require.NotEqual(t, -1, n)
}
func TestWithSetting(t *testing.T) {
func (h *HttplibTestSuite) TestWithSetting() {
t := h.T()
v := "beego"
var setting BeegoHTTPSettings
setting.EnableCookie = true
@@ -181,75 +239,68 @@ func TestWithSetting(t *testing.T) {
setting.ReadWriteTimeout = 5 * time.Second
SetDefaultSetting(setting)
str, err := Get("http://httpbin.org/get").String()
str, err := Get("http://localhost:8080/get").String()
require.NoError(t, err)
t.Log(str)
n := strings.Index(str, v)
if n == -1 {
t.Fatal(v + " not found in user-agent")
}
require.NotEqual(t, -1, n)
}
func TestToJson(t *testing.T) {
req := Get("http://httpbin.org/ip")
func (h *HttplibTestSuite) TestToJson() {
t := h.T()
req := Get("http://localhost:8080/ip")
resp, err := req.Response()
require.NoError(t, err)
t.Log(resp)
// httpbin will return http remote addr
type IP struct {
Origin string `json:"origin"`
}
var ip IP
err = req.ToJSON(&ip)
require.NoError(t, err)
t.Log(ip.Origin)
require.Equal(t, "127.0.0.1", ip.Origin)
ips := strings.Split(ip.Origin, ",")
if len(ips) == 0 {
t.Fatal("response is not valid ip")
}
for i := range ips {
if net.ParseIP(strings.TrimSpace(ips[i])).To4() == nil {
t.Fatal("response is not valid ip")
}
}
require.NotEmpty(t, ips)
}
func TestToFile(t *testing.T) {
func (h *HttplibTestSuite) TestToFile() {
t := h.T()
f := "beego_testfile"
req := Get("http://httpbin.org/ip")
req := Get("http://localhost:8080/ip")
err := req.ToFile(f)
require.NoError(t, err)
defer os.Remove(f)
b, err := ioutil.ReadFile(f)
if n := bytes.Index(b, []byte("origin")); n == -1 {
t.Fatal(err)
}
b, err := os.ReadFile(f)
n := bytes.Index(b, []byte("origin"))
require.NotEqual(t, -1, n)
}
func TestToFileDir(t *testing.T) {
func (h *HttplibTestSuite) TestToFileDir() {
t := h.T()
f := "./files/beego_testfile"
req := Get("http://httpbin.org/ip")
req := Get("http://localhost:8080/ip")
err := req.ToFile(f)
require.NoError(t, err)
defer os.RemoveAll("./files")
b, err := ioutil.ReadFile(f)
if n := bytes.Index(b, []byte("origin")); n == -1 {
t.Fatal(err)
}
b, err := os.ReadFile(f)
require.NoError(t, err)
n := bytes.Index(b, []byte("origin"))
require.NotEqual(t, -1, n)
}
func TestHeader(t *testing.T) {
req := Get("http://httpbin.org/headers")
func (h *HttplibTestSuite) TestHeader() {
t := h.T()
req := Get("http://localhost:8080/headers")
req.Header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.57 Safari/537.36")
str, err := req.String()
_, err := req.String()
require.NoError(t, err)
t.Log(str)
}
// TestAddFilter make sure that AddFilters only work for the specific request
func TestAddFilter(t *testing.T) {
func (h *HttplibTestSuite) TestAddFilter() {
t := h.T()
req := Get("http://beego.vip")
req.AddFilters(func(next Filter) Filter {
return func(ctx context.Context, req *BeegoHTTPRequest) (*http.Response, error) {
@@ -261,7 +312,8 @@ func TestAddFilter(t *testing.T) {
assert.Equal(t, 1, len(req.setting.FilterChains)-len(r.setting.FilterChains))
}
func TestFilterChainOrder(t *testing.T) {
func (h *HttplibTestSuite) TestFilterChainOrder() {
t := h.T()
req := Get("http://beego.vip")
req.AddFilters(func(next Filter) Filter {
return func(ctx context.Context, req *BeegoHTTPRequest) (*http.Response, error) {
@@ -282,24 +334,34 @@ func TestFilterChainOrder(t *testing.T) {
assert.Equal(t, "first", string(data))
}
func TestHead(t *testing.T) {
func (h *HttplibTestSuite) TestHead() {
t := h.T()
req := Head("http://beego.vip")
assert.NotNil(t, req)
assert.Equal(t, "HEAD", req.req.Method)
}
func TestDelete(t *testing.T) {
func (h *HttplibTestSuite) TestDelete() {
t := h.T()
req := Delete("http://beego.vip")
assert.NotNil(t, req)
assert.Equal(t, "DELETE", req.req.Method)
}
func TestPost(t *testing.T) {
func (h *HttplibTestSuite) TestPost() {
t := h.T()
req := Post("http://beego.vip")
assert.NotNil(t, req)
assert.Equal(t, "POST", req.req.Method)
}
func (h *HttplibTestSuite) TestPut() {
t := h.T()
req := Put("http://beego.vip")
assert.NotNil(t, req)
assert.Equal(t, "PUT", req.req.Method)
}
func TestNewBeegoRequest(t *testing.T) {
req := NewBeegoRequest("http://beego.vip", "GET")
assert.NotNil(t, req)
@@ -341,12 +403,6 @@ func TestBeegoHTTPRequestSetProtocolVersion(t *testing.T) {
assert.Equal(t, 1, req.req.ProtoMinor)
}
func TestPut(t *testing.T) {
req := Put("http://beego.vip")
assert.NotNil(t, req)
assert.Equal(t, "PUT", req.req.Method)
}
func TestBeegoHTTPRequestHeader(t *testing.T) {
req := Post("http://beego.vip")
key, value := "test-header", "test-header-value"