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

3
client/cache/bloom_filter_cache_test.go vendored
View File

@@ -23,9 +23,10 @@ import (
"testing"
"time"
"github.com/beego/beego/v2/core/berror"
"github.com/bits-and-blooms/bloom/v3"
"github.com/stretchr/testify/assert"
"github.com/beego/beego/v2/core/berror"
)
type MockDB struct {

6
client/cache/cache.go vendored
View File

@@ -16,7 +16,9 @@
// Usage:
//
// import(
// "github.com/beego/beego/v2/client/cache"
//
// "github.com/beego/beego/v2/client/cache"
//
// )
//
// bm, err := cache.NewCache("memory", `{"interval":60}`)
@@ -27,7 +29,6 @@
// bm.Get("astaxie")
// bm.IsExist("astaxie")
// bm.Delete("astaxie")
//
package cache
import (
@@ -39,6 +40,7 @@ import (
// Cache interface contains all behaviors for cache adapter.
// usage:
//
// cache.Register("file",cache.NewFileCache) // this operation is run in init method of file.go.
// c,err := cache.NewCache("file","{....}")
// c.Put("key",value, 3600 * time.Second)

9
client/cache/memcache/memcache.go vendored
View File

@@ -20,12 +20,13 @@
//
// Usage:
// import(
// _ "github.com/beego/beego/v2/client/cache/memcache"
// "github.com/beego/beego/v2/client/cache"
//
// _ "github.com/beego/beego/v2/client/cache/memcache"
// "github.com/beego/beego/v2/client/cache"
//
// )
//
// bm, err := cache.NewCache("memcache", `{"conn":"127.0.0.1:11211"}`)
//
// bm, err := cache.NewCache("memcache", `{"conn":"127.0.0.1:11211"}`)
package memcache
import (

9
client/cache/redis/redis.go vendored
View File

@@ -20,12 +20,13 @@
//
// Usage:
// import(
// _ "github.com/beego/beego/v2/client/cache/redis"
// "github.com/beego/beego/v2/client/cache"
//
// _ "github.com/beego/beego/v2/client/cache/redis"
// "github.com/beego/beego/v2/client/cache"
//
// )
//
// bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:11211"}`)
//
// bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:11211"}`)
package redis
import (

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"

6
client/orm/mock/mock_orm.go
View File

@@ -106,8 +106,10 @@ func MockDeleteWithCtx(tableName string, affectedRow int64, err error) *Mock {
// Now you may be need to use golang/mock to generate QueryM2M mock instance
// Or use DoNothingQueryM2Mer
// for example:
// post := Post{Id: 4}
// m2m := Ormer.QueryM2M(&post, "Tags")
//
// post := Post{Id: 4}
// m2m := Ormer.QueryM2M(&post, "Tags")
//
// when you write test code:
// MockQueryM2MWithCtx("post", "Tags", mockM2Mer)
// "post" is the table name of model Post structure

6
client/orm/orm.go
View File

@@ -50,7 +50,6 @@
// // delete
// num, err = o.Delete(&u)
// }
//
package orm
import (
@@ -324,8 +323,9 @@ func (o *ormBase) QueryM2MWithCtx(_ context.Context, md interface{}, name string
// args are limit, offset int and order string.
//
// example:
// orm.LoadRelated(post,"Tags")
// for _,tag := range post.Tags{...}
//
// orm.LoadRelated(post,"Tags")
// for _,tag := range post.Tags{...}
//
// make sure the relation is defined in model struct tags.
func (o *ormBase) LoadRelated(md interface{}, name string, args ...utils.KV) (int64, error) {

7
client/orm/orm_querym2m.go
View File

@@ -30,9 +30,10 @@ type queryM2M struct {
// add models to origin models when creating queryM2M.
// example:
// m2m := orm.QueryM2M(post,"Tag")
// m2m.Add(&Tag1{},&Tag2{})
// for _,tag := range post.Tags{}
//
// m2m := orm.QueryM2M(post,"Tag")
// m2m.Add(&Tag1{},&Tag2{})
// for _,tag := range post.Tags{}
//
// make sure the relation is defined in post model struct tag.
func (o *queryM2M) Add(mds ...interface{}) (int64, error) {

30
client/orm/orm_queryset.go
View File

@@ -43,9 +43,10 @@ const (
)
// ColValue do the field raw changes. e.g Nums = Nums + 10. usage:
// Params{
// "Nums": ColValue(Col_Add, 10),
// }
//
// Params{
// "Nums": ColValue(Col_Add, 10),
// }
func ColValue(opt operator, value interface{}) interface{} {
switch opt {
case ColAdd, ColMinus, ColMultiply, ColExcept, ColBitAnd, ColBitRShift,
@@ -260,8 +261,9 @@ func (o *querySet) DeleteWithCtx(ctx context.Context) (int64, error) {
// return an insert queryer.
// it can be used in times.
// example:
// i,err := sq.PrepareInsert()
// i.Add(&user1{},&user2{})
//
// i,err := sq.PrepareInsert()
// i.Add(&user1{},&user2{})
func (o *querySet) PrepareInsert() (Inserter, error) {
return o.PrepareInsertWithCtx(context.Background())
}
@@ -339,10 +341,11 @@ func (o *querySet) ValuesFlatWithCtx(ctx context.Context, result *ParamsList, ex
// name | value
// total | 100
// found | 200
// to map[string]interface{}{
// "total": 100,
// "found": 200,
// }
//
// to map[string]interface{}{
// "total": 100,
// "found": 200,
// }
func (o *querySet) RowsToMap(result *Params, keyCol, valueCol string) (int64, error) {
panic(ErrNotImplement)
}
@@ -353,10 +356,11 @@ func (o *querySet) RowsToMap(result *Params, keyCol, valueCol string) (int64, er
// name | value
// total | 100
// found | 200
// to struct {
// Total int
// Found int
// }
//
// to struct {
// Total int
// Found int
// }
func (o *querySet) RowsToStruct(ptrStruct interface{}, keyCol, valueCol string) (int64, error) {
panic(ErrNotImplement)
}

18
client/orm/orm_raw.go
View File

@@ -874,10 +874,11 @@ func (o *rawSet) ValuesFlat(container *ParamsList, cols ...string) (int64, error
// name | value
// total | 100
// found | 200
// to map[string]interface{}{
// "total": 100,
// "found": 200,
// }
//
// to map[string]interface{}{
// "total": 100,
// "found": 200,
// }
func (o *rawSet) RowsToMap(result *Params, keyCol, valueCol string) (int64, error) {
return o.queryRowsTo(result, keyCol, valueCol)
}
@@ -888,10 +889,11 @@ func (o *rawSet) RowsToMap(result *Params, keyCol, valueCol string) (int64, erro
// name | value
// total | 100
// found | 200
// to struct {
// Total int
// Found int
// }
//
// to struct {
// Total int
// Found int
// }
func (o *rawSet) RowsToStruct(ptrStruct interface{}, keyCol, valueCol string) (int64, error) {
return o.queryRowsTo(ptrStruct, keyCol, valueCol)
}

61
client/orm/types.go
View File

@@ -27,12 +27,14 @@ import (
// TableNaming is usually used by model
// when you custom your table name, please implement this interfaces
// for example:
// type User struct {
// ...
// }
// func (u *User) TableName() string {
// return "USER_TABLE"
// }
//
// type User struct {
// ...
// }
//
// func (u *User) TableName() string {
// return "USER_TABLE"
// }
type TableNameI interface {
TableName() string
}
@@ -40,12 +42,14 @@ type TableNameI interface {
// TableEngineI is usually used by model
// when you want to use specific engine, like myisam, you can implement this interface
// for example:
// type User struct {
// ...
// }
// func (u *User) TableEngine() string {
// return "myisam"
// }
//
// type User struct {
// ...
// }
//
// func (u *User) TableEngine() string {
// return "myisam"
// }
type TableEngineI interface {
TableEngine() string
}
@@ -53,12 +57,14 @@ type TableEngineI interface {
// TableIndexI is usually used by model
// when you want to create indexes, you can implement this interface
// for example:
// type User struct {
// ...
// }
// func (u *User) TableIndex() [][]string {
// return [][]string{{"Name"}}
// }
//
// type User struct {
// ...
// }
//
// func (u *User) TableIndex() [][]string {
// return [][]string{{"Name"}}
// }
type TableIndexI interface {
TableIndex() [][]string
}
@@ -66,12 +72,14 @@ type TableIndexI interface {
// TableUniqueI is usually used by model
// when you want to create unique indexes, you can implement this interface
// for example:
// type User struct {
// ...
// }
// func (u *User) TableUnique() [][]string {
// return [][]string{{"Email"}}
// }
//
// type User struct {
// ...
// }
//
// func (u *User) TableUnique() [][]string {
// return [][]string{{"Email"}}
// }
type TableUniqueI interface {
TableUnique() [][]string
}
@@ -526,8 +534,9 @@ type RawPreparer interface {
// RawSeter raw query seter
// create From Ormer.Raw
// for example:
// sql := fmt.Sprintf("SELECT %sid%s,%sname%s FROM %suser%s WHERE id = ?",Q,Q,Q,Q,Q,Q)
// rs := Ormer.Raw(sql, 1)
//
// sql := fmt.Sprintf("SELECT %sid%s,%sname%s FROM %suser%s WHERE id = ?",Q,Q,Q,Q,Q,Q)
// rs := Ormer.Raw(sql, 1)
type RawSeter interface {
// execute sql and get result
Exec() (sql.Result, error)