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

fix sonar Part3

Browse Source
This commit is contained in:
Ming Deng 2021-02-03 19:42:42 +08:00
parent 6f98a01bfd
commit 62aa0188c4
18 changed files with 513 additions and 977 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -25,4 +25,5 @@
## Fix Sonar ## Fix Sonar
- [4473](https://github.com/beego/beego/pull/4473) - [4473](https://github.com/beego/beego/pull/4473)
- [4474](https://github.com/beego/beego/pull/4474) - [4474](https://github.com/beego/beego/pull/4474)
- [4479](https://github.com/beego/beego/pull/4479)

9
adapter/session/sess_cookie_test.go
View File

@ -22,6 +22,8 @@ import (
"testing" "testing"
) )
const setCookieKey = "Set-Cookie"
func TestCookie(t *testing.T) { func TestCookie(t *testing.T) {
config := `{"cookieName":"gosessionid","enableSetCookie":false,"gclifetime":3600,"ProviderConfig":"{\"cookieName\":\"gosessionid\",\"securityKey\":\"beegocookiehashkey\"}"}` config := `{"cookieName":"gosessionid","enableSetCookie":false,"gclifetime":3600,"ProviderConfig":"{\"cookieName\":\"gosessionid\",\"securityKey\":\"beegocookiehashkey\"}"}`
conf := new(ManagerConfig) conf := new(ManagerConfig)
@ -46,7 +48,8 @@ func TestCookie(t *testing.T) {
t.Fatal("get username error") t.Fatal("get username error")
} }
sess.SessionRelease(w) sess.SessionRelease(w)
if cookiestr := w.Header().Get("Set-Cookie"); cookiestr == "" {
if cookiestr := w.Header().Get(setCookieKey); cookiestr == "" {
t.Fatal("setcookie error") t.Fatal("setcookie error")
} else { } else {
parts := strings.Split(strings.TrimSpace(cookiestr), ";") parts := strings.Split(strings.TrimSpace(cookiestr), ";")
@ -79,7 +82,7 @@ func TestDestorySessionCookie(t *testing.T) {
// request again ,will get same sesssion id . // request again ,will get same sesssion id .
r1, _ := http.NewRequest("GET", "/", nil) r1, _ := http.NewRequest("GET", "/", nil)
r1.Header.Set("Cookie", w.Header().Get("Set-Cookie")) r1.Header.Set("Cookie", w.Header().Get(setCookieKey))
w = httptest.NewRecorder() w = httptest.NewRecorder()
newSession, err := globalSessions.SessionStart(w, r1) newSession, err := globalSessions.SessionStart(w, r1)
if err != nil { if err != nil {
@ -92,7 +95,7 @@ func TestDestorySessionCookie(t *testing.T) {
// After destroy session , will get a new session id . // After destroy session , will get a new session id .
globalSessions.SessionDestroy(w, r1) globalSessions.SessionDestroy(w, r1)
r2, _ := http.NewRequest("GET", "/", nil) r2, _ := http.NewRequest("GET", "/", nil)
r2.Header.Set("Cookie", w.Header().Get("Set-Cookie")) r2.Header.Set("Cookie", w.Header().Get(setCookieKey))
w = httptest.NewRecorder() w = httptest.NewRecorder()
newSession, err = globalSessions.SessionStart(w, r2) newSession, err = globalSessions.SessionStart(w, r2)

229
adapter/templatefunc_test.go
View File

@ -19,19 +19,15 @@ import (
"net/url" "net/url"
"testing" "testing"
"time" "time"
"github.com/stretchr/testify/assert"
) )
func TestSubstr(t *testing.T) { func TestSubstr(t *testing.T) {
s := `012345` s := `012345`
if Substr(s, 0, 2) != "01" { assert.Equal(t, "01", Substr(s, 0, 2))
t.Error("should be equal") assert.Equal(t, "012345", Substr(s, 0, 100))
} assert.Equal(t, "012345", Substr(s, 12, 100))
if Substr(s, 0, 100) != "012345" {
t.Error("should be equal")
}
if Substr(s, 12, 100) != "012345" {
t.Error("should be equal")
}
} }
func TestHtml2str(t *testing.T) { func TestHtml2str(t *testing.T) {
@ -39,73 +35,51 @@ func TestHtml2str(t *testing.T) {
\n` \n`
if HTML2str(h) != "123\\n\n\\n" { assert.Equal(t, "123\\n\n\\n", HTML2str(h))
t.Error("should be equal")
}
} }
func TestDateFormat(t *testing.T) { func TestDateFormat(t *testing.T) {
ts := "Mon, 01 Jul 2013 13:27:42 CST" ts := "Mon, 01 Jul 2013 13:27:42 CST"
tt, _ := time.Parse(time.RFC1123, ts) tt, _ := time.Parse(time.RFC1123, ts)
if ss := DateFormat(tt, "2006-01-02 15:04:05"); ss != "2013-07-01 13:27:42" { assert.Equal(t, "2013-07-01 13:27:42", DateFormat(tt, "2006-01-02 15:04:05"))
t.Errorf("2013-07-01 13:27:42 does not equal %v", ss)
}
} }
func TestDate(t *testing.T) { func TestDate(t *testing.T) {
ts := "Mon, 01 Jul 2013 13:27:42 CST" ts := "Mon, 01 Jul 2013 13:27:42 CST"
tt, _ := time.Parse(time.RFC1123, ts) tt, _ := time.Parse(time.RFC1123, ts)
if ss := Date(tt, "Y-m-d H:i:s"); ss != "2013-07-01 13:27:42" { assert.Equal(t, "2013-07-01 13:27:42", Date(tt, "Y-m-d H:i:s"))
t.Errorf("2013-07-01 13:27:42 does not equal %v", ss)
} assert.Equal(t, "13-7-1 01:27:42 PM", Date(tt, "y-n-j h:i:s A"))
if ss := Date(tt, "y-n-j h:i:s A"); ss != "13-7-1 01:27:42 PM" { assert.Equal(t, "Mon, 01 Jul 2013 1:27:42 pm", Date(tt, "D, d M Y g:i:s a"))
t.Errorf("13-7-1 01:27:42 PM does not equal %v", ss) assert.Equal(t, "Monday, 01 July 2013 13:27:42", Date(tt, "l, d F Y G:i:s"))
}
if ss := Date(tt, "D, d M Y g:i:s a"); ss != "Mon, 01 Jul 2013 1:27:42 pm" {
t.Errorf("Mon, 01 Jul 2013 1:27:42 pm does not equal %v", ss)
}
if ss := Date(tt, "l, d F Y G:i:s"); ss != "Monday, 01 July 2013 13:27:42" {
t.Errorf("Monday, 01 July 2013 13:27:42 does not equal %v", ss)
}
} }
func TestCompareRelated(t *testing.T) { func TestCompareRelated(t *testing.T) {
if !Compare("abc", "abc") { assert.True(t, Compare("abc", "abc"))
t.Error("should be equal")
} assert.False(t, Compare("abc", "aBc"))
if Compare("abc", "aBc") {
t.Error("should be not equal") assert.True(t, Compare("1", 1))
}
if !Compare("1", 1) { assert.False(t, CompareNot("abc", "abc"))
t.Error("should be equal")
} assert.True(t, CompareNot("abc", "aBc"))
if CompareNot("abc", "abc") { assert.True(t, NotNil("a string"))
t.Error("should be equal")
}
if !CompareNot("abc", "aBc") {
t.Error("should be not equal")
}
if !NotNil("a string") {
t.Error("should not be nil")
}
} }
func TestHtmlquote(t *testing.T) { func TestHtmlquote(t *testing.T) {
h := `<' ”“&">` h := `<' ”“&">`
s := `<' ”“&">` s := `<' ”“&">`
if Htmlquote(s) != h { assert.Equal(t, h, Htmlquote(s))
t.Error("should be equal")
}
} }
func TestHtmlunquote(t *testing.T) { func TestHtmlunquote(t *testing.T) {
h := `&lt;&#39;&nbsp;&rdquo;&ldquo;&amp;&#34;&gt;` h := `&lt;&#39;&nbsp;&rdquo;&ldquo;&amp;&#34;&gt;`
s := `<' ”“&">` s := `<' ”“&">`
if Htmlunquote(h) != s { assert.Equal(t, s, Htmlunquote(h))
t.Error("should be equal")
}
} }
func TestParseForm(t *testing.T) { func TestParseForm(t *testing.T) {
@ -148,55 +122,42 @@ func TestParseForm(t *testing.T) {
"hobby": []string{"", "Basketball", "Football"}, "hobby": []string{"", "Basketball", "Football"},
"memo": []string{"nothing"}, "memo": []string{"nothing"},
} }
if err := ParseForm(form, u); err == nil {
t.Fatal("nothing will be changed") assert.NotNil(t, ParseForm(form, u))
}
if err := ParseForm(form, &u); err != nil { assert.Nil(t, ParseForm(form, &u))
t.Fatal(err)
} assert.Equal(t, 0, u.ID)
if u.ID != 0 {
t.Errorf("ID should equal 0 but got %v", u.ID) assert.Equal(t, 0, len(u.tag))
}
if len(u.tag) != 0 { assert.Equal(t, "test", u.Name)
t.Errorf("tag's length should equal 0 but got %v", len(u.tag))
} assert.Equal(t, 40, u.Age)
if u.Name.(string) != "test" {
t.Errorf("Name should equal `test` but got `%v`", u.Name.(string)) assert.Equal(t, "test@gmail.com", u.Email)
}
if u.Age != 40 { assert.Equal(t, "I am an engineer!", u.Intro)
t.Errorf("Age should equal 40 but got %v", u.Age)
} assert.True(t, u.StrBool)
if u.Email != "test@gmail.com" {
t.Errorf("Email should equal `test@gmail.com` but got `%v`", u.Email)
}
if u.Intro != "I am an engineer!" {
t.Errorf("Intro should equal `I am an engineer!` but got `%v`", u.Intro)
}
if !u.StrBool {
t.Errorf("strboll should equal `true`, but got `%v`", u.StrBool)
}
y, m, d := u.Date.Date() y, m, d := u.Date.Date()
if y != 2014 || m.String() != "November" || d != 12 {
t.Errorf("Date should equal `2014-11-12`, but got `%v`", u.Date.String()) assert.Equal(t, 2014, y)
} assert.Equal(t, "November", m.String())
if u.Organization != "beego" { assert.Equal(t, 12, d)
t.Errorf("Organization should equal `beego`, but got `%v`", u.Organization)
} assert.Equal(t, "beego", u.Organization)
if u.Title != "CXO" {
t.Errorf("Title should equal `CXO`, but got `%v`", u.Title) assert.Equal(t, "CXO", u.Title)
}
if u.Hobby[0] != "" { assert.Equal(t, "", u.Hobby[0])
t.Errorf("Hobby should equal ``, but got `%v`", u.Hobby[0])
} assert.Equal(t, "Basketball", u.Hobby[1])
if u.Hobby[1] != "Basketball" {
t.Errorf("Hobby should equal `Basketball`, but got `%v`", u.Hobby[1]) assert.Equal(t, "Football", u.Hobby[2])
}
if u.Hobby[2] != "Football" { assert.Equal(t, 0, len(u.Memo))
t.Errorf("Hobby should equal `Football`, but got `%v`", u.Hobby[2])
}
if len(u.Memo) != 0 {
t.Errorf("Memo's length should equal 0 but got %v", len(u.Memo))
}
} }
func TestRenderForm(t *testing.T) { func TestRenderForm(t *testing.T) {
@ -212,18 +173,14 @@ func TestRenderForm(t *testing.T) {
u := user{Name: "test", Intro: "Some Text"} u := user{Name: "test", Intro: "Some Text"}
output := RenderForm(u) output := RenderForm(u)
if output != template.HTML("") { assert.Equal(t, template.HTML(""), output)
t.Errorf("output should be empty but got %v", output)
}
output = RenderForm(&u) output = RenderForm(&u)
result := template.HTML( result := template.HTML(
`Name: <input name="username" type="text" value="test"></br>` + `Name: <input name="username" type="text" value="test"></br>` +
`年龄：<input name="age" type="text" value="0"></br>` + `年龄：<input name="age" type="text" value="0"></br>` +
`Sex: <input name="Sex" type="text" value=""></br>` + `Sex: <input name="Sex" type="text" value=""></br>` +
`Intro: <textarea name="Intro">Some Text</textarea>`) `Intro: <textarea name="Intro">Some Text</textarea>`)
if output != result { assert.Equal(t, result, output)
t.Errorf("output should equal `%v` but got `%v`", result, output)
}
} }
func TestMapGet(t *testing.T) { func TestMapGet(t *testing.T) {
@ -233,29 +190,18 @@ func TestMapGet(t *testing.T) {
"1": 2, "1": 2,
} }
if res, err := MapGet(m1, "a"); err == nil { res, err := MapGet(m1, "a")
if res.(int64) != 1 { assert.Nil(t, err)
t.Errorf("Should return 1, but return %v", res) assert.Equal(t, int64(1), res)
}
} else {
t.Errorf("Error happens %v", err)
}
if res, err := MapGet(m1, "1"); err == nil { res, err = MapGet(m1, "1")
if res.(int64) != 2 { assert.Nil(t, err)
t.Errorf("Should return 2, but return %v", res) assert.Equal(t, int64(2), res)
}
} else {
t.Errorf("Error happens %v", err)
}
if res, err := MapGet(m1, 1); err == nil {
if res.(int64) != 2 { res, err = MapGet(m1, 1)
t.Errorf("Should return 2, but return %v", res) assert.Nil(t, err)
} assert.Equal(t, int64(2), res)
} else {
t.Errorf("Error happens %v", err)
}
// test 2 level map // test 2 level map
m2 := M{ m2 := M{
@ -264,13 +210,9 @@ func TestMapGet(t *testing.T) {
}, },
} }
if res, err := MapGet(m2, 1, 2); err == nil { res, err = MapGet(m2, 1, 2)
if res.(float64) != 3.5 { assert.Nil(t, err)
t.Errorf("Should return 3.5, but return %v", res) assert.Equal(t, 3.5, res)
}
} else {
t.Errorf("Error happens %v", err)
}
// test 5 level map // test 5 level map
m5 := M{ m5 := M{
@ -285,20 +227,13 @@ func TestMapGet(t *testing.T) {
}, },
} }
if res, err := MapGet(m5, 1, 2, 3, 4, 5); err == nil { res, err = MapGet(m5, 1, 2, 3, 4, 5)
if res.(float64) != 1.2 { assert.Nil(t, err)
t.Errorf("Should return 1.2, but return %v", res) assert.Equal(t, 1.2, res)
}
} else {
t.Errorf("Error happens %v", err)
}
// check whether element not exists in map // check whether element not exists in map
if res, err := MapGet(m5, 5, 4, 3, 2, 1); err == nil { res, err = MapGet(m5, 5, 4, 3, 2, 1)
if res != nil { assert.Nil(t, err)
t.Errorf("Should return nil, but return %v", res) assert.Nil(t, res)
}
} else {
t.Errorf("Error happens %v", err)
}
} }

17
adapter/toolbox/statistics_test.go
View File

@ -21,13 +21,16 @@ import (
) )
func TestStatics(t *testing.T) { func TestStatics(t *testing.T) {
StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(2000)) userApi := "/api/user"
StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(120000)) post := "POST"
StatisticsMap.AddStatistics("GET", "/api/user", "&admin.user", time.Duration(13000)) adminUser := "&admin.user"
StatisticsMap.AddStatistics("POST", "/api/admin", "&admin.user", time.Duration(14000)) StatisticsMap.AddStatistics(post, userApi, adminUser, time.Duration(2000))
StatisticsMap.AddStatistics("POST", "/api/user/astaxie", "&admin.user", time.Duration(12000)) StatisticsMap.AddStatistics(post, userApi, adminUser, time.Duration(120000))
StatisticsMap.AddStatistics("POST", "/api/user/xiemengjun", "&admin.user", time.Duration(13000)) StatisticsMap.AddStatistics("GET", userApi, adminUser, time.Duration(13000))
StatisticsMap.AddStatistics("DELETE", "/api/user", "&admin.user", time.Duration(1400)) StatisticsMap.AddStatistics(post, "/api/admin", adminUser, time.Duration(14000))
StatisticsMap.AddStatistics(post, "/api/user/astaxie", adminUser, time.Duration(12000))
StatisticsMap.AddStatistics(post, "/api/user/xiemengjun", adminUser, time.Duration(13000))
StatisticsMap.AddStatistics("DELETE", userApi, adminUser, time.Duration(1400))
t.Log(StatisticsMap.GetMap()) t.Log(StatisticsMap.GetMap())
data := StatisticsMap.GetMapData() data := StatisticsMap.GetMapData()

2
adapter/utils/rand_test.go
View File

@ -16,7 +16,7 @@ package utils
import "testing" import "testing"
func TestRand_01(t *testing.T) { func TestRand01(t *testing.T) {
bs0 := RandomCreateBytes(16) bs0 := RandomCreateBytes(16)
bs1 := RandomCreateBytes(16) bs1 := RandomCreateBytes(16)

263
adapter/validation/validation_test.go
View File

@ -18,131 +18,83 @@ import (
"regexp" "regexp"
"testing" "testing"
"time" "time"
"github.com/stretchr/testify/assert"
) )
func TestRequired(t *testing.T) { func TestRequired(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.Required(nil, "nil").Ok { assert.False(t, valid.Required(nil, "nil").Ok)
t.Error("nil object should be false") assert.True(t, valid.Required(true, "bool").Ok)
}
if !valid.Required(true, "bool").Ok { assert.True(t, valid.Required(false, "bool").Ok)
t.Error("Bool value should always return true") assert.False(t, valid.Required("", "string").Ok)
} assert.False(t, valid.Required(" ", "string").Ok)
if !valid.Required(false, "bool").Ok { assert.False(t, valid.Required("\n", "string").Ok)
t.Error("Bool value should always return true")
} assert.True(t, valid.Required("astaxie", "string").Ok)
if valid.Required("", "string").Ok { assert.False(t, valid.Required(0, "zero").Ok)
t.Error("\"'\" string should be false")
} assert.True(t, valid.Required(1, "int").Ok)
if valid.Required(" ", "string").Ok {
t.Error("\" \" string should be false") // For #2361 assert.True(t, valid.Required(time.Now(), "time").Ok)
}
if valid.Required("\n", "string").Ok { assert.False(t, valid.Required([]string{}, "emptySlice").Ok)
t.Error("new line string should be false") // For #2361
} assert.True(t, valid.Required([]interface{}{"ok"}, "slice").Ok)
if !valid.Required("astaxie", "string").Ok {
t.Error("string should be true")
}
if valid.Required(0, "zero").Ok {
t.Error("Integer should not be equal 0")
}
if !valid.Required(1, "int").Ok {
t.Error("Integer except 0 should be true")
}
if !valid.Required(time.Now(), "time").Ok {
t.Error("time should be true")
}
if valid.Required([]string{}, "emptySlice").Ok {
t.Error("empty slice should be false")
}
if !valid.Required([]interface{}{"ok"}, "slice").Ok {
t.Error("slice should be true")
}
} }
func TestMin(t *testing.T) { func TestMin(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.Min(-1, 0, "min0").Ok { assert.False(t, valid.Min(-1, 0, "min0").Ok)
t.Error("-1 is less than the minimum value of 0 should be false") assert.True(t, valid.Min(1, 0, "min0").Ok)
}
if !valid.Min(1, 0, "min0").Ok {
t.Error("1 is greater or equal than the minimum value of 0 should be true")
}
} }
func TestMax(t *testing.T) { func TestMax(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.Max(1, 0, "max0").Ok { assert.False(t, valid.Max(1, 0, "max0").Ok)
t.Error("1 is greater than the minimum value of 0 should be false") assert.True(t, valid.Max(-1, 0, "max0").Ok)
}
if !valid.Max(-1, 0, "max0").Ok {
t.Error("-1 is less or equal than the maximum value of 0 should be true")
}
} }
func TestRange(t *testing.T) { func TestRange(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.Range(-1, 0, 1, "range0_1").Ok { assert.False(t, valid.Range(-1, 0, 1, "range0_1").Ok)
t.Error("-1 is between 0 and 1 should be false")
} assert.True(t, valid.Range(1, 0, 1, "range0_1").Ok)
if !valid.Range(1, 0, 1, "range0_1").Ok {
t.Error("1 is between 0 and 1 should be true")
}
} }
func TestMinSize(t *testing.T) { func TestMinSize(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.MinSize("", 1, "minSize1").Ok { assert.False(t, valid.MinSize("", 1, "minSize1").Ok)
t.Error("the length of \"\" is less than the minimum value of 1 should be false")
} assert.True(t, valid.MinSize("ok", 1, "minSize1").Ok)
if !valid.MinSize("ok", 1, "minSize1").Ok { assert.False(t, valid.MinSize([]string{}, 1, "minSize1").Ok)
t.Error("the length of \"ok\" is greater or equal than the minimum value of 1 should be true") assert.True(t, valid.MinSize([]interface{}{"ok"}, 1, "minSize1").Ok)
}
if valid.MinSize([]string{}, 1, "minSize1").Ok {
t.Error("the length of empty slice is less than the minimum value of 1 should be false")
}
if !valid.MinSize([]interface{}{"ok"}, 1, "minSize1").Ok {
t.Error("the length of [\"ok\"] is greater or equal than the minimum value of 1 should be true")
}
} }
func TestMaxSize(t *testing.T) { func TestMaxSize(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.MaxSize("ok", 1, "maxSize1").Ok { assert.False(t, valid.MaxSize("ok", 1, "maxSize1").Ok)
t.Error("the length of \"ok\" is greater than the maximum value of 1 should be false") assert.True(t, valid.MaxSize("", 1, "maxSize1").Ok)
} assert.False(t, valid.MaxSize([]interface{}{"ok", false}, 1, "maxSize1").Ok)
if !valid.MaxSize("", 1, "maxSize1").Ok { assert.True(t, valid.MaxSize([]string{}, 1, "maxSize1").Ok)
t.Error("the length of \"\" is less or equal than the maximum value of 1 should be true")
}
if valid.MaxSize([]interface{}{"ok", false}, 1, "maxSize1").Ok {
t.Error("the length of [\"ok\", false] is greater than the maximum value of 1 should be false")
}
if !valid.MaxSize([]string{}, 1, "maxSize1").Ok {
t.Error("the length of empty slice is less or equal than the maximum value of 1 should be true")
}
} }
func TestLength(t *testing.T) { func TestLength(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.Length("", 1, "length1").Ok { assert.False(t, valid.Length("", 1, "length1").Ok)
t.Error("the length of \"\" must equal 1 should be false") assert.True(t, valid.Length("1", 1, "length1").Ok)
}
if !valid.Length("1", 1, "length1").Ok { assert.False(t, valid.Length([]string{}, 1, "length1").Ok)
t.Error("the length of \"1\" must equal 1 should be true") assert.True(t, valid.Length([]interface{}{"ok"}, 1, "length1").Ok)
}
if valid.Length([]string{}, 1, "length1").Ok {
t.Error("the length of empty slice must equal 1 should be false")
}
if !valid.Length([]interface{}{"ok"}, 1, "length1").Ok {
t.Error("the length of [\"ok\"] must equal 1 should be true")
}
} }
func TestAlpha(t *testing.T) { func TestAlpha(t *testing.T) {
@ -178,13 +130,16 @@ func TestAlphaNumeric(t *testing.T) {
} }
} }
const email = "suchuangji@gmail.com"
func TestMatch(t *testing.T) { func TestMatch(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.Match("suchuangji@gmail", regexp.MustCompile(`^\w+@\w+\.\w+$`), "match").Ok { if valid.Match("suchuangji@gmail", regexp.MustCompile(`^\w+@\w+\.\w+$`), "match").Ok {
t.Error("\"suchuangji@gmail\" match \"^\\w+@\\w+\\.\\w+$\" should be false") t.Error("\"suchuangji@gmail\" match \"^\\w+@\\w+\\.\\w+$\" should be false")
} }
if !valid.Match("suchuangji@gmail.com", regexp.MustCompile(`^\w+@\w+\.\w+$`), "match").Ok {
if !valid.Match(email, regexp.MustCompile(`^\w+@\w+\.\w+$`), "match").Ok {
t.Error("\"suchuangji@gmail\" match \"^\\w+@\\w+\\.\\w+$\" should be true") t.Error("\"suchuangji@gmail\" match \"^\\w+@\\w+\\.\\w+$\" should be true")
} }
} }
@ -217,7 +172,7 @@ func TestEmail(t *testing.T) {
if valid.Email("not@a email", "email").Ok { if valid.Email("not@a email", "email").Ok {
t.Error("\"not@a email\" is a valid email address should be false") t.Error("\"not@a email\" is a valid email address should be false")
} }
if !valid.Email("suchuangji@gmail.com", "email").Ok { if !valid.Email(email, "email").Ok {
t.Error("\"suchuangji@gmail.com\" is a valid email address should be true") t.Error("\"suchuangji@gmail.com\" is a valid email address should be true")
} }
if valid.Email("@suchuangji@gmail.com", "email").Ok { if valid.Email("@suchuangji@gmail.com", "email").Ok {
@ -242,7 +197,7 @@ func TestIP(t *testing.T) {
func TestBase64(t *testing.T) { func TestBase64(t *testing.T) {
valid := Validation{} valid := Validation{}
if valid.Base64("suchuangji@gmail.com", "base64").Ok { if valid.Base64(email, "base64").Ok {
t.Error("\"suchuangji@gmail.com\" are a valid base64 characters should be false") t.Error("\"suchuangji@gmail.com\" are a valid base64 characters should be false")
} }
if !valid.Base64("c3VjaHVhbmdqaUBnbWFpbC5jb20=", "base64").Ok { if !valid.Base64("c3VjaHVhbmdqaUBnbWFpbC5jb20=", "base64").Ok {
@ -370,44 +325,25 @@ func TestValid(t *testing.T) {
u := user{Name: "test@/test/;com", Age: 40} u := user{Name: "test@/test/;com", Age: 40}
b, err := valid.Valid(u) b, err := valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.True(t, b)
}
if !b {
t.Error("validation should be passed")
}
uptr := &user{Name: "test", Age: 40} uptr := &user{Name: "test", Age: 40}
valid.Clear() valid.Clear()
b, err = valid.Valid(uptr) b, err = valid.Valid(uptr)
if err != nil {
t.Fatal(err) assert.Nil(t, err)
} assert.False(t, b)
if b { assert.Equal(t, 1, len(valid.Errors))
t.Error("validation should not be passed") assert.Equal(t, "Name.Match", valid.Errors[0].Key)
}
if len(valid.Errors) != 1 {
t.Fatalf("valid errors len should be 1 but got %d", len(valid.Errors))
}
if valid.Errors[0].Key != "Name.Match" {
t.Errorf("Message key should be `Name.Match` but got %s", valid.Errors[0].Key)
}
u = user{Name: "test@/test/;com", Age: 180} u = user{Name: "test@/test/;com", Age: 180}
valid.Clear() valid.Clear()
b, err = valid.Valid(u) b, err = valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
} assert.Equal(t, 1, len(valid.Errors))
if b { assert.Equal(t, "Age.Range.", valid.Errors[0].Key)
t.Error("validation should not be passed")
}
if len(valid.Errors) != 1 {
t.Fatalf("valid errors len should be 1 but got %d", len(valid.Errors))
}
if valid.Errors[0].Key != "Age.Range." {
t.Errorf("Message key should be `Age.Range` but got %s", valid.Errors[0].Key)
}
} }
func TestRecursiveValid(t *testing.T) { func TestRecursiveValid(t *testing.T) {
@ -432,12 +368,8 @@ func TestRecursiveValid(t *testing.T) {
u := Account{Password: "abc123_", U: User{}} u := Account{Password: "abc123_", U: User{}}
b, err := valid.RecursiveValid(u) b, err := valid.RecursiveValid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
}
if b {
t.Error("validation should not be passed")
}
} }
func TestSkipValid(t *testing.T) { func TestSkipValid(t *testing.T) {
@ -474,21 +406,13 @@ func TestSkipValid(t *testing.T) {
valid := Validation{} valid := Validation{}
b, err := valid.Valid(u) b, err := valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
}
if b {
t.Fatal("validation should not be passed")
}
valid = Validation{RequiredFirst: true} valid = Validation{RequiredFirst: true}
b, err = valid.Valid(u) b, err = valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.True(t, b)
}
if !b {
t.Fatal("validation should be passed")
}
} }
func TestPointer(t *testing.T) { func TestPointer(t *testing.T) {
@ -506,12 +430,8 @@ func TestPointer(t *testing.T) {
valid := Validation{} valid := Validation{}
b, err := valid.Valid(u) b, err := valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
}
if b {
t.Fatal("validation should not be passed")
}
validEmail := "a@a.com" validEmail := "a@a.com"
u = User{ u = User{
@ -521,12 +441,8 @@ func TestPointer(t *testing.T) {
valid = Validation{RequiredFirst: true} valid = Validation{RequiredFirst: true}
b, err = valid.Valid(u) b, err = valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.True(t, b)
}
if !b {
t.Fatal("validation should be passed")
}
u = User{ u = User{
ReqEmail: &validEmail, ReqEmail: &validEmail,
@ -535,12 +451,8 @@ func TestPointer(t *testing.T) {
valid = Validation{} valid = Validation{}
b, err = valid.Valid(u) b, err = valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
}
if b {
t.Fatal("validation should not be passed")
}
invalidEmail := "a@a" invalidEmail := "a@a"
u = User{ u = User{
@ -550,12 +462,8 @@ func TestPointer(t *testing.T) {
valid = Validation{RequiredFirst: true} valid = Validation{RequiredFirst: true}
b, err = valid.Valid(u) b, err = valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
}
if b {
t.Fatal("validation should not be passed")
}
u = User{ u = User{
ReqEmail: &validEmail, ReqEmail: &validEmail,
@ -564,12 +472,8 @@ func TestPointer(t *testing.T) {
valid = Validation{} valid = Validation{}
b, err = valid.Valid(u) b, err = valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
}
if b {
t.Fatal("validation should not be passed")
}
} }
func TestCanSkipAlso(t *testing.T) { func TestCanSkipAlso(t *testing.T) {
@ -589,21 +493,14 @@ func TestCanSkipAlso(t *testing.T) {
valid := Validation{RequiredFirst: true} valid := Validation{RequiredFirst: true}
b, err := valid.Valid(u) b, err := valid.Valid(u)
if err != nil { assert.Nil(t, err)
t.Fatal(err) assert.False(t, b)
}
if b {
t.Fatal("validation should not be passed")
}
valid = Validation{RequiredFirst: true} valid = Validation{RequiredFirst: true}
valid.CanSkipAlso("Range") valid.CanSkipAlso("Range")
b, err = valid.Valid(u) b, err = valid.Valid(u)
if err != nil {
t.Fatal(err) assert.Nil(t, err)
} assert.True(t, b)
if !b {
t.Fatal("validation should be passed")
}
} }

193
client/cache/cache_test.go vendored
View File

@ -21,13 +21,13 @@ import (
"sync" "sync"
"testing" "testing"
"time" "time"
"github.com/stretchr/testify/assert"
) )
func TestCacheIncr(t *testing.T) { func TestCacheIncr(t *testing.T) {
bm, err := NewCache("memory", `{"interval":20}`) bm, err := NewCache("memory", `{"interval":20}`)
if err != nil { assert.Nil(t, err)
t.Error("init err")
}
// timeoutDuration := 10 * time.Second // timeoutDuration := 10 * time.Second
bm.Put(context.Background(), "edwardhey", 0, time.Second*20) bm.Put(context.Background(), "edwardhey", 0, time.Second*20)
@ -48,9 +48,7 @@ func TestCacheIncr(t *testing.T) {
func TestCache(t *testing.T) { func TestCache(t *testing.T) {
bm, err := NewCache("memory", `{"interval":1}`) bm, err := NewCache("memory", `{"interval":1}`)
if err != nil { assert.Nil(t, err)
t.Error("init err")
}
timeoutDuration := 5 * time.Second timeoutDuration := 5 * time.Second
if err = bm.Put(context.Background(), "astaxie", 1, timeoutDuration); err != nil { if err = bm.Put(context.Background(), "astaxie", 1, timeoutDuration); err != nil {
t.Error("set Error", err) t.Error("set Error", err)
@ -81,70 +79,48 @@ func TestCache(t *testing.T) {
testDecrOverFlow(t, bm, timeoutDuration) testDecrOverFlow(t, bm, timeoutDuration)
bm.Delete(context.Background(), "astaxie") bm.Delete(context.Background(), "astaxie")
if res, _ := bm.IsExist(context.Background(), "astaxie"); res { res, _ := bm.IsExist(context.Background(), "astaxie")
t.Error("delete err") assert.False(t, res)
}
// test GetMulti assert.Nil(t, bm.Put(context.Background(), "astaxie", "author", timeoutDuration))
if err = bm.Put(context.Background(), "astaxie", "author", timeoutDuration); err != nil {
t.Error("set Error", err)
}
if res, _ := bm.IsExist(context.Background(), "astaxie"); !res {
t.Error("check err")
}
if v, _ := bm.Get(context.Background(), "astaxie"); v.(string) != "author" {
t.Error("get err")
}
if err = bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration); err != nil { res, _ = bm.IsExist(context.Background(), "astaxie")
t.Error("set Error", err) assert.True(t, res)
}
if res, _ := bm.IsExist(context.Background(), "astaxie1"); !res { v, _ := bm.Get(context.Background(), "astaxie")
t.Error("check err") assert.Equal(t, "author", v)
}
assert.Nil(t, bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration))
res, _ = bm.IsExist(context.Background(), "astaxie1")
assert.True(t, res)
vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"}) vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("GetMulti ERROR") assert.Equal(t, "author", vv[0])
} assert.Equal(t,"author1", vv[1])
if vv[0].(string) != "author" {
t.Error("GetMulti ERROR")
}
if vv[1].(string) != "author1" {
t.Error("GetMulti ERROR")
}
vv, err = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"}) vv, err = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("GetMulti ERROR") assert.Nil(t, vv[0])
} assert.Equal(t, "author1", vv[1])
if vv[0] != nil {
t.Error("GetMulti ERROR") assert.NotNil(t, err)
} assert.Equal(t, "key [astaxie0] error: key not exist", err.Error())
if vv[1].(string) != "author1" {
t.Error("GetMulti ERROR")
}
if err != nil && err.Error() != "key [astaxie0] error: the key isn't exist" {
t.Error("GetMulti ERROR")
}
} }
func TestFileCache(t *testing.T) { func TestFileCache(t *testing.T) {
bm, err := NewCache("file", `{"CachePath":"cache","FileSuffix":".bin","DirectoryLevel":"2","EmbedExpiry":"0"}`) bm, err := NewCache("file", `{"CachePath":"cache","FileSuffix":".bin","DirectoryLevel":"2","EmbedExpiry":"0"}`)
if err != nil { assert.Nil(t, err)
t.Error("init err")
}
timeoutDuration := 10 * time.Second timeoutDuration := 10 * time.Second
if err = bm.Put(context.Background(), "astaxie", 1, timeoutDuration); err != nil { assert.Nil(t, bm.Put(context.Background(), "astaxie", 1, timeoutDuration))
t.Error("set Error", err)
}
if res, _ := bm.IsExist(context.Background(), "astaxie"); !res {
t.Error("check err")
}
if v, _ := bm.Get(context.Background(), "astaxie"); v.(int) != 1 { res, _ := bm.IsExist(context.Background(), "astaxie")
t.Error("get err") assert.True(t, res)
} v, _ := bm.Get(context.Background(), "astaxie")
assert.Equal(t, 1, v)
// test different integer type for incr & decr // test different integer type for incr & decr
testMultiTypeIncrDecr(t, bm, timeoutDuration) testMultiTypeIncrDecr(t, bm, timeoutDuration)
@ -154,54 +130,35 @@ func TestFileCache(t *testing.T) {
testDecrOverFlow(t, bm, timeoutDuration) testDecrOverFlow(t, bm, timeoutDuration)
bm.Delete(context.Background(), "astaxie") bm.Delete(context.Background(), "astaxie")
if res, _ := bm.IsExist(context.Background(), "astaxie"); res { res, _ = bm.IsExist(context.Background(), "astaxie")
t.Error("delete err") assert.False(t, res)
}
// test string // test string
if err = bm.Put(context.Background(), "astaxie", "author", timeoutDuration); err != nil { assert.Nil(t, bm.Put(context.Background(), "astaxie", "author", timeoutDuration))
t.Error("set Error", err) res, _ = bm.IsExist(context.Background(), "astaxie")
} assert.True(t, res)
if res, _ := bm.IsExist(context.Background(), "astaxie"); !res {
t.Error("check err") v, _ = bm.Get(context.Background(), "astaxie")
} assert.Equal(t, "author", v)
if v, _ := bm.Get(context.Background(), "astaxie"); v.(string) != "author" {
t.Error("get err")
}
// test GetMulti // test GetMulti
if err = bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration); err != nil { assert.Nil(t, bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration))
t.Error("set Error", err)
} res, _ = bm.IsExist(context.Background(), "astaxie1")
if res, _ := bm.IsExist(context.Background(), "astaxie1"); !res { assert.True(t, res)
t.Error("check err")
}
vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"}) vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("GetMulti ERROR") assert.Equal(t, "author", vv[0])
} assert.Equal(t, "author1", vv[1])
if vv[0].(string) != "author" {
t.Error("GetMulti ERROR")
}
if vv[1].(string) != "author1" {
t.Error("GetMulti ERROR")
}
vv, err = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"}) vv, err = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("GetMulti ERROR")
}
if vv[0] != nil {
t.Error("GetMulti ERROR")
}
if vv[1].(string) != "author1" {
t.Error("GetMulti ERROR")
}
if err == nil {
t.Error("GetMulti ERROR")
}
assert.Nil(t, vv[0])
assert.Equal(t, "author1", vv[1])
assert.NotNil(t, err)
os.RemoveAll("cache") os.RemoveAll("cache")
} }
@ -215,53 +172,33 @@ func testMultiTypeIncrDecr(t *testing.T, c Cache, timeout time.Duration) {
} }
func testIncrDecr(t *testing.T, c Cache, beforeIncr interface{}, afterIncr interface{}, timeout time.Duration) { func testIncrDecr(t *testing.T, c Cache, beforeIncr interface{}, afterIncr interface{}, timeout time.Duration) {
var err error
ctx := context.Background() ctx := context.Background()
key := "incDecKey" key := "incDecKey"
if err = c.Put(ctx, key, beforeIncr, timeout); err != nil {
t.Error("Get Error", err)
}
if err = c.Incr(ctx, key); err != nil { assert.Nil(t, c.Put(ctx, key, beforeIncr, timeout))
t.Error("Incr Error", err) assert.Nil(t, c.Incr(ctx, key))
}
if v, _ := c.Get(ctx, key); v != afterIncr {
t.Error("Get Error")
}
if err = c.Decr(ctx, key); err != nil { v, _ := c.Get(ctx, key)
t.Error("Decr Error", err) assert.Equal(t, afterIncr, v)
}
if v, _ := c.Get(ctx, key); v != beforeIncr { assert.Nil(t, c.Decr(ctx, key))
t.Error("Get Error")
}
if err := c.Delete(ctx, key); err != nil { v, _ = c.Get(ctx, key)
t.Error("Delete Error") assert.Equal(t, v, beforeIncr)
} assert.Nil(t, c.Delete(ctx, key))
} }
func testIncrOverFlow(t *testing.T, c Cache, timeout time.Duration) { func testIncrOverFlow(t *testing.T, c Cache, timeout time.Duration) {
var err error
ctx := context.Background() ctx := context.Background()
key := "incKey" key := "incKey"
assert.Nil(t, c.Put(ctx, key, int64(math.MaxInt64), timeout))
// int64 // int64
if err = c.Put(ctx, key, int64(math.MaxInt64), timeout); err != nil {
t.Error("Put Error: ", err.Error())
return
}
defer func() { defer func() {
if err = c.Delete(ctx, key); err != nil { assert.Nil(t, c.Delete(ctx, key))
t.Errorf("Delete error: %s", err.Error())
}
}() }()
if err = c.Incr(ctx, key); err == nil { assert.NotNil(t, c.Incr(ctx, key))
t.Error("Incr error")
return
}
} }
func testDecrOverFlow(t *testing.T, c Cache, timeout time.Duration) { func testDecrOverFlow(t *testing.T, c Cache, timeout time.Duration) {

202
client/cache/calc_utils_test.go vendored
View File

@ -4,6 +4,8 @@ import (
"math" "math"
"strconv" "strconv"
"testing" "testing"
"github.com/stretchr/testify/assert"
) )
func TestIncr(t *testing.T) { func TestIncr(t *testing.T) {
@ -11,116 +13,62 @@ func TestIncr(t *testing.T) {
var originVal interface{} = int(1) var originVal interface{} = int(1)
var updateVal interface{} = int(2) var updateVal interface{} = int(2)
val, err := incr(originVal) val, err := incr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("incr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("incr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = incr(int(1<<(strconv.IntSize-1) - 1)) _, err = incr(int(1<<(strconv.IntSize-1) - 1))
if err == nil { assert.NotNil(t, err)
t.Error("incr failed")
return
}
// int32 // int32
originVal = int32(1) originVal = int32(1)
updateVal = int32(2) updateVal = int32(2)
val, err = incr(originVal) val, err = incr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("incr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("incr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = incr(int32(math.MaxInt32)) _, err = incr(int32(math.MaxInt32))
if err == nil { assert.NotNil(t, err)
t.Error("incr failed")
return
}
// int64 // int64
originVal = int64(1) originVal = int64(1)
updateVal = int64(2) updateVal = int64(2)
val, err = incr(originVal) val, err = incr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("incr failed, err: %s", err.Error())
return assert.Equal(t, updateVal, val)
}
if val != updateVal {
t.Errorf("incr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = incr(int64(math.MaxInt64)) _, err = incr(int64(math.MaxInt64))
if err == nil { assert.NotNil(t, err)
t.Error("incr failed")
return
}
// uint // uint
originVal = uint(1) originVal = uint(1)
updateVal = uint(2) updateVal = uint(2)
val, err = incr(originVal) val, err = incr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("incr failed, err: %s", err.Error())
return
}
if val != updateVal {
t.Errorf("incr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = incr(uint(1<<(strconv.IntSize) - 1))
if err == nil {
t.Error("incr failed")
return
}
assert.Equal(t, updateVal, val)
_, err = incr(uint(1<<(strconv.IntSize) - 1))
assert.NotNil(t, err)
// uint32 // uint32
originVal = uint32(1) originVal = uint32(1)
updateVal = uint32(2) updateVal = uint32(2)
val, err = incr(originVal) val, err = incr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("incr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("incr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = incr(uint32(math.MaxUint32)) _, err = incr(uint32(math.MaxUint32))
if err == nil { assert.NotNil(t, err)
t.Error("incr failed")
return
}
// uint64 // uint64
originVal = uint64(1) originVal = uint64(1)
updateVal = uint64(2) updateVal = uint64(2)
val, err = incr(originVal) val, err = incr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("incr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("incr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = incr(uint64(math.MaxUint64)) _, err = incr(uint64(math.MaxUint64))
if err == nil { assert.NotNil(t, err)
t.Error("incr failed")
return
}
// other type // other type
_, err = incr("string") _, err = incr("string")
if err == nil { assert.NotNil(t, err)
t.Error("incr failed")
return
}
} }
func TestDecr(t *testing.T) { func TestDecr(t *testing.T) {
@ -128,114 +76,58 @@ func TestDecr(t *testing.T) {
var originVal interface{} = int(2) var originVal interface{} = int(2)
var updateVal interface{} = int(1) var updateVal interface{} = int(1)
val, err := decr(originVal) val, err := decr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("decr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("decr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = decr(int(-1 << (strconv.IntSize - 1))) _, err = decr(int(-1 << (strconv.IntSize - 1)))
if err == nil {
t.Error("decr failed") assert.NotNil(t, err)
return
}
// int32 // int32
originVal = int32(2) originVal = int32(2)
updateVal = int32(1) updateVal = int32(1)
val, err = decr(originVal) val, err = decr(originVal)
if err != nil {
t.Errorf("decr failed, err: %s", err.Error()) assert.Nil(t, err)
return assert.Equal(t, updateVal, val)
}
if val != updateVal {
t.Errorf("decr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = decr(int32(math.MinInt32)) _, err = decr(int32(math.MinInt32))
if err == nil { assert.NotNil(t, err)
t.Error("decr failed")
return
}
// int64 // int64
originVal = int64(2) originVal = int64(2)
updateVal = int64(1) updateVal = int64(1)
val, err = decr(originVal) val, err = decr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("decr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("decr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = decr(int64(math.MinInt64)) _, err = decr(int64(math.MinInt64))
if err == nil { assert.NotNil(t, err)
t.Error("decr failed")
return
}
// uint // uint
originVal = uint(2) originVal = uint(2)
updateVal = uint(1) updateVal = uint(1)
val, err = decr(originVal) val, err = decr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("decr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("decr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = decr(uint(0)) _, err = decr(uint(0))
if err == nil { assert.NotNil(t, err)
t.Error("decr failed")
return
}
// uint32 // uint32
originVal = uint32(2) originVal = uint32(2)
updateVal = uint32(1) updateVal = uint32(1)
val, err = decr(originVal) val, err = decr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("decr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("decr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = decr(uint32(0)) _, err = decr(uint32(0))
if err == nil { assert.NotNil(t, err)
t.Error("decr failed")
return
}
// uint64 // uint64
originVal = uint64(2) originVal = uint64(2)
updateVal = uint64(1) updateVal = uint64(1)
val, err = decr(originVal) val, err = decr(originVal)
if err != nil { assert.Nil(t, err)
t.Errorf("decr failed, err: %s", err.Error()) assert.Equal(t, updateVal, val)
return
}
if val != updateVal {
t.Errorf("decr failed, expect %v, but %v actually", updateVal, val)
return
}
_, err = decr(uint64(0)) _, err = decr(uint64(0))
if err == nil { assert.NotNil(t, err)
t.Error("decr failed")
return
}
// other type // other type
_, err = decr("string") _, err = decr("string")
if err == nil { assert.NotNil(t, err)
t.Error("decr failed")
return
}
} }

120
client/cache/conv_test.go vendored
View File

@ -16,128 +16,74 @@ package cache
import ( import (
"testing" "testing"
"github.com/stretchr/testify/assert"
) )
func TestGetString(t *testing.T) { func TestGetString(t *testing.T) {
var t1 = "test1" var t1 = "test1"
if "test1" != GetString(t1) {
t.Error("get string from string error")
}
var t2 = []byte("test2")
if "test2" != GetString(t2) {
t.Error("get string from byte array error")
}
var t3 = 1
if "1" != GetString(t3) {
t.Error("get string from int error")
}
var t4 int64 = 1
if "1" != GetString(t4) {
t.Error("get string from int64 error")
}
var t5 = 1.1
if "1.1" != GetString(t5) {
t.Error("get string from float64 error")
}
if "" != GetString(nil) { assert.Equal(t, "test1", GetString(t1))
t.Error("get string from nil error") var t2 = []byte("test2")
} assert.Equal(t, "test2", GetString(t2))
var t3 = 1
assert.Equal(t, "1", GetString(t3))
var t4 int64 = 1
assert.Equal(t, "1", GetString(t4))
var t5 = 1.1
assert.Equal(t, "1.1", GetString(t5))
assert.Equal(t, "", GetString(nil))
} }
func TestGetInt(t *testing.T) { func TestGetInt(t *testing.T) {
var t1 = 1 var t1 = 1
if 1 != GetInt(t1) { assert.Equal(t, 1, GetInt(t1))
t.Error("get int from int error")
}
var t2 int32 = 32 var t2 int32 = 32
if 32 != GetInt(t2) { assert.Equal(t, 32, GetInt(t2))
t.Error("get int from int32 error")
}
var t3 int64 = 64 var t3 int64 = 64
if 64 != GetInt(t3) { assert.Equal(t, 64, GetInt(t3))
t.Error("get int from int64 error")
}
var t4 = "128" var t4 = "128"
if 128 != GetInt(t4) {
t.Error("get int from num string error") assert.Equal(t, 128, GetInt(t4))
} assert.Equal(t, 0, GetInt(nil))
if 0 != GetInt(nil) {
t.Error("get int from nil error")
}
} }
func TestGetInt64(t *testing.T) { func TestGetInt64(t *testing.T) {
var i int64 = 1 var i int64 = 1
var t1 = 1 var t1 = 1
if i != GetInt64(t1) { assert.Equal(t, i, GetInt64(t1))
t.Error("get int64 from int error")
}
var t2 int32 = 1 var t2 int32 = 1
if i != GetInt64(t2) {
t.Error("get int64 from int32 error") assert.Equal(t, i, GetInt64(t2))
}
var t3 int64 = 1 var t3 int64 = 1
if i != GetInt64(t3) { assert.Equal(t, i, GetInt64(t3))
t.Error("get int64 from int64 error")
}
var t4 = "1" var t4 = "1"
if i != GetInt64(t4) { assert.Equal(t, i, GetInt64(t4))
t.Error("get int64 from num string error") assert.Equal(t, int64(0), GetInt64(nil))
}
if 0 != GetInt64(nil) {
t.Error("get int64 from nil")
}
} }
func TestGetFloat64(t *testing.T) { func TestGetFloat64(t *testing.T) {
var f = 1.11 var f = 1.11
var t1 float32 = 1.11 var t1 float32 = 1.11
if f != GetFloat64(t1) { assert.Equal(t, f, GetFloat64(t1))
t.Error("get float64 from float32 error")
}
var t2 = 1.11 var t2 = 1.11
if f != GetFloat64(t2) { assert.Equal(t, f, GetFloat64(t2))
t.Error("get float64 from float64 error")
}
var t3 = "1.11" var t3 = "1.11"
if f != GetFloat64(t3) { assert.Equal(t, f, GetFloat64(t3))
t.Error("get float64 from string error")
}
var f2 float64 = 1 var f2 float64 = 1
var t4 = 1 var t4 = 1
if f2 != GetFloat64(t4) { assert.Equal(t, f2, GetFloat64(t4))
t.Error("get float64 from int error")
}
if 0 != GetFloat64(nil) { assert.Equal(t, float64(0), GetFloat64(nil))
t.Error("get float64 from nil error")
}
} }
func TestGetBool(t *testing.T) { func TestGetBool(t *testing.T) {
var t1 = true var t1 = true
if !GetBool(t1) { assert.True(t, GetBool(t1))
t.Error("get bool from bool error")
}
var t2 = "true" var t2 = "true"
if !GetBool(t2) { assert.True(t, GetBool(t2))
t.Error("get bool from string error")
}
if GetBool(nil) {
t.Error("get bool from nil error")
}
}
func byteArrayEquals(a []byte, b []byte) bool { assert.False(t, GetBool(nil))
if len(a) != len(b) {
return false
}
for i, v := range a {
if v != b[i] {
return false
}
}
return true
} }

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

@ -84,7 +84,7 @@ func (rc *Cache) GetMulti(ctx context.Context, keys []string) ([]interface{}, er
keysErr := make([]string, 0) keysErr := make([]string, 0)
for i, ki := range keys { for i, ki := range keys {
if _, ok := mv[ki]; !ok { if _, ok := mv[ki]; !ok {
keysErr = append(keysErr, fmt.Sprintf("key [%s] error: %s", ki, "the key isn't exist")) keysErr = append(keysErr, fmt.Sprintf("key [%s] error: %s", ki, "key not exist"))
continue continue
} }
rv[i] = mv[ki].Value rv[i] = mv[ki].Value

111
client/cache/memcache/memcache_test.go vendored
View File

@ -23,6 +23,7 @@ import (
"time" "time"
_ "github.com/bradfitz/gomemcache/memcache" _ "github.com/bradfitz/gomemcache/memcache"
"github.com/stretchr/testify/assert"
"github.com/beego/beego/v2/client/cache" "github.com/beego/beego/v2/client/cache"
) )
@ -34,78 +35,63 @@ func TestMemcacheCache(t *testing.T) {
} }
bm, err := cache.NewCache("memcache", fmt.Sprintf(`{"conn": "%s"}`, addr)) bm, err := cache.NewCache("memcache", fmt.Sprintf(`{"conn": "%s"}`, addr))
if err != nil { assert.Nil(t, err)
t.Error("init err")
}
timeoutDuration := 10 * time.Second timeoutDuration := 10 * time.Second
if err = bm.Put(context.Background(), "astaxie", "1", timeoutDuration); err != nil {
t.Error("set Error", err) assert.Nil(t, bm.Put(context.Background(), "astaxie", "1", timeoutDuration))
} res, _ := bm.IsExist(context.Background(), "astaxie")
if res, _ := bm.IsExist(context.Background(), "astaxie"); !res { assert.True(t, res)
t.Error("check err")
}
time.Sleep(11 * time.Second) time.Sleep(11 * time.Second)
if res, _ := bm.IsExist(context.Background(), "astaxie"); res { res, _ = bm.IsExist(context.Background(), "astaxie")
t.Error("check err") assert.False(t, res)
}
if err = bm.Put(context.Background(), "astaxie", "1", timeoutDuration); err != nil { assert.Nil(t, bm.Put(context.Background(), "astaxie", "1", timeoutDuration))
t.Error("set Error", err)
}
val, _ := bm.Get(context.Background(), "astaxie") val, _ := bm.Get(context.Background(), "astaxie")
if v, err := strconv.Atoi(string(val.([]byte))); err != nil || v != 1 { v, err := strconv.Atoi(string(val.([]byte)))
t.Error("get err") assert.Nil(t, err)
} assert.Equal(t, 1, v)
if err = bm.Incr(context.Background(), "astaxie"); err != nil { assert.Nil(t, bm.Incr(context.Background(), "astaxie"))
t.Error("Incr Error", err)
}
val, _ = bm.Get(context.Background(), "astaxie") val, _ = bm.Get(context.Background(), "astaxie")
if v, err := strconv.Atoi(string(val.([]byte))); err != nil || v != 2 { v, err = strconv.Atoi(string(val.([]byte)))
t.Error("get err") assert.Nil(t, err)
} assert.Equal(t, 2, v)
if err = bm.Decr(context.Background(), "astaxie"); err != nil { assert.Nil(t, bm.Decr(context.Background(), "astaxie"))
t.Error("Decr Error", err)
}
val, _ = bm.Get(context.Background(), "astaxie") val, _ = bm.Get(context.Background(), "astaxie")
if v, err := strconv.Atoi(string(val.([]byte))); err != nil || v != 1 { v, err = strconv.Atoi(string(val.([]byte)))
t.Error("get err") assert.Nil(t, err)
} assert.Equal(t, 1, v)
bm.Delete(context.Background(), "astaxie") bm.Delete(context.Background(), "astaxie")
if res, _ := bm.IsExist(context.Background(), "astaxie"); res {
t.Error("delete err")
}
res, _ = bm.IsExist(context.Background(), "astaxie")
assert.False(t, res)
assert.Nil(t,bm.Put(context.Background(), "astaxie", "author", timeoutDuration) )
// test string // test string
if err = bm.Put(context.Background(), "astaxie", "author", timeoutDuration); err != nil { res, _ = bm.IsExist(context.Background(), "astaxie")
t.Error("set Error", err) assert.True(t, res)
}
if res, _ := bm.IsExist(context.Background(), "astaxie"); !res {
t.Error("check err")
}
val, _ = bm.Get(context.Background(), "astaxie") val, _ = bm.Get(context.Background(), "astaxie")
if v := val.([]byte); string(v) != "author" { vs := val.([]byte)
t.Error("get err") assert.Equal(t, "author", string(vs))
}
// test GetMulti // test GetMulti
if err = bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration); err != nil { assert.Nil(t, bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration))
t.Error("set Error", err)
}
if res, _ := bm.IsExist(context.Background(), "astaxie1"); !res { res, _ = bm.IsExist(context.Background(), "astaxie1")
t.Error("check err") assert.True(t, res)
}
vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"}) vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("GetMulti ERROR")
}
if string(vv[0].([]byte)) != "author" && string(vv[0].([]byte)) != "author1" { if string(vv[0].([]byte)) != "author" && string(vv[0].([]byte)) != "author1" {
t.Error("GetMulti ERROR") t.Error("GetMulti ERROR")
} }
@ -114,21 +100,14 @@ func TestMemcacheCache(t *testing.T) {
} }
vv, err = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"}) vv, err = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("GetMulti ERROR") assert.Nil(t, vv[0])
}
if vv[0] != nil {
t.Error("GetMulti ERROR")
}
if string(vv[1].([]byte)) != "author1" {
t.Error("GetMulti ERROR")
}
if err != nil && err.Error() == "key [astaxie0] error: key isn't exist" {
t.Error("GetMulti ERROR")
}
assert.Equal(t, "author1", string(vv[1].([]byte)))
assert.NotNil(t, err)
assert.Equal(t, "key [astaxie0] error: key not exist", err.Error())
assert.Nil(t, bm.ClearAll(context.Background()))
// test clear all // test clear all
if err = bm.ClearAll(context.Background()); err != nil {
t.Error("clear all err")
}
} }

11
client/cache/memory.go vendored
View File

@ -29,6 +29,8 @@ var (
DefaultEvery = 60 // 1 minute DefaultEvery = 60 // 1 minute
) )
const keyNotExistMsg = "key not exist"
// MemoryItem stores memory cache item. // MemoryItem stores memory cache item.
type MemoryItem struct { type MemoryItem struct {
val interface{} val interface{}
@ -70,7 +72,7 @@ func (bc *MemoryCache) Get(ctx context.Context, key string) (interface{}, error)
} }
return itm.val, nil return itm.val, nil
} }
return nil, errors.New("the key isn't exist") return nil, errors.New(keyNotExistMsg)
} }
// GetMulti gets caches from memory. // GetMulti gets caches from memory.
@ -112,7 +114,8 @@ func (bc *MemoryCache) Delete(ctx context.Context, key string) error {
bc.Lock() bc.Lock()
defer bc.Unlock() defer bc.Unlock()
if _, ok := bc.items[key]; !ok { if _, ok := bc.items[key]; !ok {
return errors.New("key not exist")
return errors.New(keyNotExistMsg)
} }
delete(bc.items, key) delete(bc.items, key)
if _, ok := bc.items[key]; ok { if _, ok := bc.items[key]; ok {
@ -128,7 +131,7 @@ func (bc *MemoryCache) Incr(ctx context.Context, key string) error {
defer bc.Unlock() defer bc.Unlock()
itm, ok := bc.items[key] itm, ok := bc.items[key]
if !ok { if !ok {
return errors.New("key not exist") return errors.New(keyNotExistMsg)
} }
val, err := incr(itm.val) val, err := incr(itm.val)
@ -145,7 +148,7 @@ func (bc *MemoryCache) Decr(ctx context.Context, key string) error {
defer bc.Unlock() defer bc.Unlock()
itm, ok := bc.items[key] itm, ok := bc.items[key]
if !ok { if !ok {
return errors.New("key not exist") return errors.New(keyNotExistMsg)
} }
val, err := decr(itm.val) val, err := decr(itm.val)

139
client/cache/redis/redis_test.go vendored
View File

@ -35,96 +35,74 @@ func TestRedisCache(t *testing.T) {
} }
bm, err := cache.NewCache("redis", fmt.Sprintf(`{"conn": "%s"}`, redisAddr)) bm, err := cache.NewCache("redis", fmt.Sprintf(`{"conn": "%s"}`, redisAddr))
if err != nil { assert.Nil(t, err)
t.Error("init err") timeoutDuration := 3 * time.Second
}
timeoutDuration := 10 * time.Second
if err = bm.Put(context.Background(), "astaxie", 1, timeoutDuration); err != nil {
t.Error("set Error", err)
}
if res, _ := bm.IsExist(context.Background(), "astaxie"); !res {
t.Error("check err")
}
time.Sleep(11 * time.Second) assert.Nil(t, bm.Put(context.Background(), "astaxie", 1, timeoutDuration))
res, _ := bm.IsExist(context.Background(), "astaxie")
assert.True(t, res)
time.Sleep(5 * time.Second)
res, _ = bm.IsExist(context.Background(), "astaxie")
assert.False(t, res)
assert.Nil(t, bm.Put(context.Background(), "astaxie", 1, timeoutDuration))
if res, _ := bm.IsExist(context.Background(), "astaxie"); res {
t.Error("check err")
}
if err = bm.Put(context.Background(), "astaxie", 1, timeoutDuration); err != nil {
t.Error("set Error", err)
}
val, _ := bm.Get(context.Background(), "astaxie") val, _ := bm.Get(context.Background(), "astaxie")
if v, _ := redis.Int(val, err); v != 1 { v, _ := redis.Int(val, err)
t.Error("get err") assert.Equal(t, 1, v)
}
if err = bm.Incr(context.Background(), "astaxie"); err != nil { assert.Nil(t, bm.Incr(context.Background(), "astaxie"))
t.Error("Incr Error", err)
}
val, _ = bm.Get(context.Background(), "astaxie") val, _ = bm.Get(context.Background(), "astaxie")
if v, _ := redis.Int(val, err); v != 2 { v, _ = redis.Int(val, err)
t.Error("get err") assert.Equal(t, 2, v)
}
if err = bm.Decr(context.Background(), "astaxie"); err != nil { assert.Nil(t, bm.Decr(context.Background(), "astaxie"))
t.Error("Decr Error", err)
}
val, _ = bm.Get(context.Background(), "astaxie") val, _ = bm.Get(context.Background(), "astaxie")
if v, _ := redis.Int(val, err); v != 1 { v, _ = redis.Int(val, err)
t.Error("get err") assert.Equal(t, 1, v)
}
bm.Delete(context.Background(), "astaxie") bm.Delete(context.Background(), "astaxie")
if res, _ := bm.IsExist(context.Background(), "astaxie"); res {
t.Error("delete err")
}
res, _ = bm.IsExist(context.Background(), "astaxie")
assert.False(t, res)
assert.Nil(t, bm.Put(context.Background(), "astaxie", "author", timeoutDuration))
// test string // test string
if err = bm.Put(context.Background(), "astaxie", "author", timeoutDuration); err != nil {
t.Error("set Error", err) res, _ = bm.IsExist(context.Background(), "astaxie")
} assert.True(t, res)
if res, _ := bm.IsExist(context.Background(), "astaxie"); !res {
t.Error("check err")
}
val, _ = bm.Get(context.Background(), "astaxie") val, _ = bm.Get(context.Background(), "astaxie")
if v, _ := redis.String(val, err); v != "author" { vs, _ := redis.String(val, err)
t.Error("get err") assert.Equal(t, "author", vs)
}
// test GetMulti // test GetMulti
if err = bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration); err != nil { assert.Nil(t, bm.Put(context.Background(), "astaxie1", "author1", timeoutDuration))
t.Error("set Error", err)
} res, _ = bm.IsExist(context.Background(), "astaxie1")
if res, _ := bm.IsExist(context.Background(), "astaxie1"); !res { assert.True(t, res)
t.Error("check err")
}
vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"}) vv, _ := bm.GetMulti(context.Background(), []string{"astaxie", "astaxie1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("GetMulti ERROR") vs, _ = redis.String(vv[0], nil)
} assert.Equal(t, "author", vs)
if v, _ := redis.String(vv[0], nil); v != "author" {
t.Error("GetMulti ERROR") vs, _ = redis.String(vv[1], nil)
} assert.Equal(t, "author1", vs)
if v, _ := redis.String(vv[1], nil); v != "author1" {
t.Error("GetMulti ERROR")
}
vv, _ = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"}) vv, _ = bm.GetMulti(context.Background(), []string{"astaxie0", "astaxie1"})
if vv[0] != nil { assert.Nil(t, vv[0])
t.Error("GetMulti ERROR")
} vs, _ = redis.String(vv[1], nil)
if v, _ := redis.String(vv[1], nil); v != "author1" { assert.Equal(t, "author1", vs)
t.Error("GetMulti ERROR")
}
// test clear all // test clear all
if err = bm.ClearAll(context.Background()); err != nil { assert.Nil(t, bm.ClearAll(context.Background()))
t.Error("clear all err")
}
} }
func TestCache_Scan(t *testing.T) { func TestCache_Scan(t *testing.T) {
@ -137,35 +115,24 @@ func TestCache_Scan(t *testing.T) {
// init // init
bm, err := cache.NewCache("redis", fmt.Sprintf(`{"conn": "%s"}`, addr)) bm, err := cache.NewCache("redis", fmt.Sprintf(`{"conn": "%s"}`, addr))
if err != nil {
t.Error("init err") assert.Nil(t, err)
}
// insert all // insert all
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
if err = bm.Put(context.Background(), fmt.Sprintf("astaxie%d", i), fmt.Sprintf("author%d", i), timeoutDuration); err != nil { assert.Nil(t, bm.Put(context.Background(), fmt.Sprintf("astaxie%d", i), fmt.Sprintf("author%d", i), timeoutDuration))
t.Error("set Error", err)
}
} }
time.Sleep(time.Second) time.Sleep(time.Second)
// scan all for the first time // scan all for the first time
keys, err := bm.(*Cache).Scan(DefaultKey + ":*") keys, err := bm.(*Cache).Scan(DefaultKey + ":*")
if err != nil { assert.Nil(t, err)
t.Error("scan Error", err)
}
assert.Equal(t, 100, len(keys), "scan all error") assert.Equal(t, 100, len(keys), "scan all error")
// clear all // clear all
if err = bm.ClearAll(context.Background()); err != nil { assert.Nil(t, bm.ClearAll(context.Background()))
t.Error("clear all err")
}
// scan all for the second time // scan all for the second time
keys, err = bm.(*Cache).Scan(DefaultKey + ":*") keys, err = bm.(*Cache).Scan(DefaultKey + ":*")
if err != nil { assert.Nil(t, err)
t.Error("scan Error", err) assert.Equal(t, 0, len(keys))
}
if len(keys) != 0 {
t.Error("scan all err")
}
} }

2
client/cache/ssdb/ssdb.go vendored
View File

@ -63,7 +63,7 @@ func (rc *Cache) GetMulti(ctx context.Context, keys []string) ([]interface{}, er
keysErr := make([]string, 0) keysErr := make([]string, 0)
for i, ki := range keys { for i, ki := range keys {
if _, ok := keyIdx[ki]; !ok { if _, ok := keyIdx[ki]; !ok {
keysErr = append(keysErr, fmt.Sprintf("key [%s] error: %s", ki, "the key isn't exist")) keysErr = append(keysErr, fmt.Sprintf("key [%s] error: %s", ki, "key not exist"))
continue continue
} }
values[i] = res[keyIdx[ki]+1] values[i] = res[keyIdx[ki]+1]

136
client/cache/ssdb/ssdb_test.go vendored
View File

@ -8,6 +8,8 @@ import (
"testing" "testing"
"time" "time"
"github.com/stretchr/testify/assert"
"github.com/beego/beego/v2/client/cache" "github.com/beego/beego/v2/client/cache"
) )
@ -19,114 +21,80 @@ func TestSsdbcacheCache(t *testing.T) {
} }
ssdb, err := cache.NewCache("ssdb", fmt.Sprintf(`{"conn": "%s"}`, ssdbAddr)) ssdb, err := cache.NewCache("ssdb", fmt.Sprintf(`{"conn": "%s"}`, ssdbAddr))
if err != nil { assert.Nil(t, err)
t.Error("init err")
}
// test put and exist // test put and exist
if res, _ := ssdb.IsExist(context.Background(), "ssdb"); res { res, _ := ssdb.IsExist(context.Background(), "ssdb")
t.Error("check err") assert.False(t, res)
} timeoutDuration := 3 * time.Second
timeoutDuration := 10 * time.Second
// timeoutDuration := -10*time.Second if timeoutDuration is negtive,it means permanent // timeoutDuration := -10*time.Second if timeoutDuration is negtive,it means permanent
if err = ssdb.Put(context.Background(), "ssdb", "ssdb", timeoutDuration); err != nil {
t.Error("set Error", err) assert.Nil(t, ssdb.Put(context.Background(), "ssdb", "ssdb", timeoutDuration))
}
if res, _ := ssdb.IsExist(context.Background(), "ssdb"); !res { res, _ = ssdb.IsExist(context.Background(), "ssdb")
t.Error("check err") assert.True(t, res)
}
// Get test done // Get test done
if err = ssdb.Put(context.Background(), "ssdb", "ssdb", timeoutDuration); err != nil { assert.Nil(t, ssdb.Put(context.Background(), "ssdb", "ssdb", timeoutDuration))
t.Error("set Error", err)
}
if v, _ := ssdb.Get(context.Background(), "ssdb"); v != "ssdb" { v, _ := ssdb.Get(context.Background(), "ssdb")
t.Error("get Error") assert.Equal(t, "ssdb", v)
}
// inc/dec test done // inc/dec test done
if err = ssdb.Put(context.Background(), "ssdb", "2", timeoutDuration); err != nil { assert.Nil(t, ssdb.Put(context.Background(), "ssdb", "2", timeoutDuration))
t.Error("set Error", err)
} assert.Nil(t, ssdb.Incr(context.Background(), "ssdb"))
if err = ssdb.Incr(context.Background(), "ssdb"); err != nil {
t.Error("incr Error", err)
}
val, _ := ssdb.Get(context.Background(), "ssdb") val, _ := ssdb.Get(context.Background(), "ssdb")
if v, err := strconv.Atoi(val.(string)); err != nil || v != 3 { v, err = strconv.Atoi(val.(string))
t.Error("get err") assert.Nil(t, err)
} assert.Equal(t, 3, v)
if err = ssdb.Decr(context.Background(), "ssdb"); err != nil { assert.Nil(t, ssdb.Decr(context.Background(), "ssdb"))
t.Error("decr error")
}
// test del // test del
if err = ssdb.Put(context.Background(), "ssdb", "3", timeoutDuration); err != nil { assert.Nil(t, ssdb.Put(context.Background(), "ssdb", "3", timeoutDuration))
t.Error("set Error", err)
}
val, _ = ssdb.Get(context.Background(), "ssdb") val, _ = ssdb.Get(context.Background(), "ssdb")
if v, err := strconv.Atoi(val.(string)); err != nil || v != 3 { v, err = strconv.Atoi(val.(string))
t.Error("get err") assert.Equal(t, 3, v)
} assert.Nil(t, err)
if err := ssdb.Delete(context.Background(), "ssdb"); err == nil {
if e, _ := ssdb.IsExist(context.Background(), "ssdb"); e {
t.Error("delete err")
}
}
assert.NotNil(t, ssdb.Delete(context.Background(), "ssdb"))
assert.Nil(t, ssdb.Put(context.Background(), "ssdb", "ssdb", -10*time.Second))
// test string // test string
if err = ssdb.Put(context.Background(), "ssdb", "ssdb", -10*time.Second); err != nil {
t.Error("set Error", err) res, _ = ssdb.IsExist(context.Background(), "ssdb")
} assert.True(t, res)
if res, _ := ssdb.IsExist(context.Background(), "ssdb"); !res {
t.Error("check err") v, _ = ssdb.Get(context.Background(), "ssdb")
} assert.Equal(t, "ssdb", v.(string))
if v, _ := ssdb.Get(context.Background(), "ssdb"); v.(string) != "ssdb" {
t.Error("get err")
}
// test GetMulti done // test GetMulti done
if err = ssdb.Put(context.Background(), "ssdb1", "ssdb1", -10*time.Second); err != nil { assert.Nil(t, ssdb.Put(context.Background(), "ssdb1", "ssdb1", -10*time.Second))
t.Error("set Error", err)
} res, _ = ssdb.IsExist(context.Background(), "ssdb1")
if res, _ := ssdb.IsExist(context.Background(), "ssdb1"); !res { assert.True(t, res)
t.Error("check err")
}
vv, _ := ssdb.GetMulti(context.Background(), []string{"ssdb", "ssdb1"}) vv, _ := ssdb.GetMulti(context.Background(), []string{"ssdb", "ssdb1"})
if len(vv) != 2 { assert.Equal(t, 2, len(vv))
t.Error("getmulti error")
} assert.Equal(t, "ssdb", vv[0])
if vv[0].(string) != "ssdb" { assert.Equal(t, "ssdb1", vv[1])
t.Error("getmulti error")
}
if vv[1].(string) != "ssdb1" {
t.Error("getmulti error")
}
vv, err = ssdb.GetMulti(context.Background(), []string{"ssdb", "ssdb11"}) vv, err = ssdb.GetMulti(context.Background(), []string{"ssdb", "ssdb11"})
if len(vv) != 2 {
t.Error("getmulti error") assert.Equal(t, 2, len(vv))
}
if vv[0].(string) != "ssdb" { assert.Equal(t, "ssdb", vv[0])
t.Error("getmulti error") assert.Nil(t, vv[1])
}
if vv[1] != nil { assert.NotNil(t, err)
t.Error("getmulti error") assert.Equal(t, "key [ssdb11] error: key not exist", err.Error())
}
if err != nil && err.Error() != "key [ssdb11] error: the key isn't exist" {
t.Error("getmulti error")
}
// test clear all done // test clear all done
if err = ssdb.ClearAll(context.Background()); err != nil { assert.Nil(t, ssdb.ClearAll(context.Background()))
t.Error("clear all err")
}
e1, _ := ssdb.IsExist(context.Background(), "ssdb") e1, _ := ssdb.IsExist(context.Background(), "ssdb")
e2, _ := ssdb.IsExist(context.Background(), "ssdb1") e2, _ := ssdb.IsExist(context.Background(), "ssdb1")
if e1 || e2 { assert.False(t, e1)
t.Error("check err") assert.False(t, e2)
}
} }

2
client/httplib/filter/opentracing/filter_test.go
View File

@ -26,7 +26,7 @@ import (
"github.com/beego/beego/v2/client/httplib" "github.com/beego/beego/v2/client/httplib"
) )
func TestFilterChainBuilder_FilterChain(t *testing.T) { func TestFilterChainBuilderFilterChain(t *testing.T) {
next := func(ctx context.Context, req *httplib.BeegoHTTPRequest) (*http.Response, error) { next := func(ctx context.Context, req *httplib.BeegoHTTPRequest) (*http.Response, error) {
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
return &http.Response{ return &http.Response{

2
client/httplib/filter/prometheus/filter_test.go
View File

@ -25,7 +25,7 @@ import (
"github.com/beego/beego/v2/client/httplib" "github.com/beego/beego/v2/client/httplib"
) )
func TestFilterChainBuilder_FilterChain(t *testing.T) { func TestFilterChainBuilderFilterChain(t *testing.T) {
next := func(ctx context.Context, req *httplib.BeegoHTTPRequest) (*http.Response, error) { next := func(ctx context.Context, req *httplib.BeegoHTTPRequest) (*http.Response, error) {
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
return &http.Response{ return &http.Response{

47
client/httplib/httplib.go
View File

@ -55,6 +55,7 @@ import (
"github.com/beego/beego/v2/core/logs" "github.com/beego/beego/v2/core/logs"
) )
const contentTypeKey = "Content-Type"
// it will be the last filter and execute request.Do // it will be the last filter and execute request.Do
var doRequestFilter = func(ctx context.Context, req *BeegoHTTPRequest) (*http.Response, error) { var doRequestFilter = func(ctx context.Context, req *BeegoHTTPRequest) (*http.Response, error) {
return req.doRequest(ctx) return req.doRequest(ctx)
@ -311,7 +312,7 @@ func (b *BeegoHTTPRequest) XMLBody(obj interface{}) (*BeegoHTTPRequest, error) {
return ioutil.NopCloser(bytes.NewReader(byts)), nil return ioutil.NopCloser(bytes.NewReader(byts)), nil
} }
b.req.ContentLength = int64(len(byts)) b.req.ContentLength = int64(len(byts))
b.req.Header.Set("Content-Type", "application/xml") b.req.Header.Set(contentTypeKey, "application/xml")
} }
return b, nil return b, nil
} }
@ -325,7 +326,7 @@ func (b *BeegoHTTPRequest) YAMLBody(obj interface{}) (*BeegoHTTPRequest, error)
} }
b.req.Body = ioutil.NopCloser(bytes.NewReader(byts)) b.req.Body = ioutil.NopCloser(bytes.NewReader(byts))
b.req.ContentLength = int64(len(byts)) b.req.ContentLength = int64(len(byts))
b.req.Header.Set("Content-Type", "application/x+yaml") b.req.Header.Set(contentTypeKey, "application/x+yaml")
} }
return b, nil return b, nil
} }
@ -339,7 +340,7 @@ func (b *BeegoHTTPRequest) JSONBody(obj interface{}) (*BeegoHTTPRequest, error)
} }
b.req.Body = ioutil.NopCloser(bytes.NewReader(byts)) b.req.Body = ioutil.NopCloser(bytes.NewReader(byts))
b.req.ContentLength = int64(len(byts)) b.req.ContentLength = int64(len(byts))
b.req.Header.Set("Content-Type", "application/json") b.req.Header.Set(contentTypeKey, "application/json")
} }
return b, nil return b, nil
} }
@ -359,34 +360,38 @@ func (b *BeegoHTTPRequest) buildURL(paramBody string) {
if (b.req.Method == "POST" || b.req.Method == "PUT" || b.req.Method == "PATCH" || b.req.Method == "DELETE") && b.req.Body == nil { if (b.req.Method == "POST" || b.req.Method == "PUT" || b.req.Method == "PATCH" || b.req.Method == "DELETE") && b.req.Body == nil {
// with files // with files
if len(b.files) > 0 { if len(b.files) > 0 {
pr, pw := io.Pipe() b.handleFiles()
bodyWriter := multipart.NewWriter(pw)
go func() {
for formname, filename := range b.files {
b.handleFileToBody(bodyWriter, formname, filename)
}
for k, v := range b.params {
for _, vv := range v {
_ = bodyWriter.WriteField(k, vv)
}
}
_ = bodyWriter.Close()
_ = pw.Close()
}()
b.Header("Content-Type", bodyWriter.FormDataContentType())
b.req.Body = ioutil.NopCloser(pr)
b.Header("Transfer-Encoding", "chunked")
return return
} }
// with params // with params
if len(paramBody) > 0 { if len(paramBody) > 0 {
b.Header("Content-Type", "application/x-www-form-urlencoded") b.Header(contentTypeKey, "application/x-www-form-urlencoded")
b.Body(paramBody) b.Body(paramBody)
} }
} }
} }
func (b *BeegoHTTPRequest) handleFiles() {
pr, pw := io.Pipe()
bodyWriter := multipart.NewWriter(pw)
go func() {
for formname, filename := range b.files {
b.handleFileToBody(bodyWriter, formname, filename)
}
for k, v := range b.params {
for _, vv := range v {
_ = bodyWriter.WriteField(k, vv)
}
}
_ = bodyWriter.Close()
_ = pw.Close()
}()
b.Header(contentTypeKey, bodyWriter.FormDataContentType())
b.req.Body = ioutil.NopCloser(pr)
b.Header("Transfer-Encoding", "chunked")
}
func (b *BeegoHTTPRequest) handleFileToBody(bodyWriter *multipart.Writer, formname string, filename string) { func (b *BeegoHTTPRequest) handleFileToBody(bodyWriter *multipart.Writer, formname string, filename string) {
fileWriter, err := bodyWriter.CreateFormFile(formname, filename) fileWriter, err := bodyWriter.CreateFormFile(formname, filename)
const errFmt = "Httplib: %+v" const errFmt = "Httplib: %+v"