From b39b2374c4c603681711cf2b2a2e73df928dd992 Mon Sep 17 00:00:00 2001 From: fanwei Date: Wed, 22 Dec 2021 20:51:03 +0800 Subject: [PATCH 001/136] Added Order() method support for gdb. --- database/gdb/gdb_model_order_group.go | 23 ++++++++++++++++++----- database/gdb/gdb_z_mysql_model_test.go | 9 +++++++++ 2 files changed, 27 insertions(+), 5 deletions(-) diff --git a/database/gdb/gdb_model_order_group.go b/database/gdb/gdb_model_order_group.go index bf8fbbc01..7922c27f9 100644 --- a/database/gdb/gdb_model_order_group.go +++ b/database/gdb/gdb_model_order_group.go @@ -6,24 +6,37 @@ package gdb -import "strings" +import ( + "github.com/gogf/gf/v2/util/gconv" + "strings" +) // Order sets the "ORDER BY" statement for the model. // // Eg: // Order("id desc") -// Order("id", "desc") // Order("id desc,name asc"). -func (m *Model) Order(orderBy ...string) *Model { +// Order("id", "desc",gdb.Raw("field(id, 3,1,2)")) +func (m *Model) Order(orderBy ...interface{}) *Model { if len(orderBy) == 0 { return m } + model := m.getModel() if model.orderBy != "" { model.orderBy += "," } - model.orderBy = model.db.GetCore().QuoteString(strings.Join(orderBy, " ")) - return model + + for _, o := range orderBy { + switch o.(type) { + case Raw: + model.orderBy += gconv.String(o) + default: + model.orderBy += model.db.GetCore().QuoteString(gconv.String(o)) + } + } + + return m } // OrderAsc sets the "ORDER BY xxx ASC" statement for the model. diff --git a/database/gdb/gdb_z_mysql_model_test.go b/database/gdb/gdb_z_mysql_model_test.go index 66482520e..42e0d761a 100644 --- a/database/gdb/gdb_z_mysql_model_test.go +++ b/database/gdb/gdb_z_mysql_model_test.go @@ -1091,6 +1091,15 @@ func Test_Model_OrderBy(t *testing.T) { t.Assert(len(result), TableSize) t.Assert(result[0]["nickname"].String(), "name_1") }) + + gtest.C(t, func(t *gtest.T) { + result, err := db.Model(table).Order(gdb.Raw("field(id, 10,1,2,3,4,5,6,7,8,9)")).All() + t.AssertNil(err) + t.Assert(len(result), TableSize) + t.Assert(result[0]["nickname"].String(), "name_10") + t.Assert(result[1]["nickname"].String(), "name_1") + t.Assert(result[2]["nickname"].String(), "name_2") + }) } func Test_Model_GroupBy(t *testing.T) { From 47cefbf6d7e912a153a205f69181e3690b5a1d11 Mon Sep 17 00:00:00 2001 From: Yu Zhan Date: Tue, 14 Dec 2021 18:13:32 +0800 Subject: [PATCH 002/136] =?UTF-8?q?=E5=85=81=E8=AE=B8=E5=A4=9A=E6=AC=A1?= =?UTF-8?q?=E8=B0=83=E7=94=A8Order?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- database/gdb/gdb_model_order_group.go | 2 +- database/gdb/gdb_z_mysql_model_test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/database/gdb/gdb_model_order_group.go b/database/gdb/gdb_model_order_group.go index bf8fbbc01..846e174f0 100644 --- a/database/gdb/gdb_model_order_group.go +++ b/database/gdb/gdb_model_order_group.go @@ -22,7 +22,7 @@ func (m *Model) Order(orderBy ...string) *Model { if model.orderBy != "" { model.orderBy += "," } - model.orderBy = model.db.GetCore().QuoteString(strings.Join(orderBy, " ")) + model.orderBy += model.db.GetCore().QuoteString(strings.Join(orderBy, " ")) return model } diff --git a/database/gdb/gdb_z_mysql_model_test.go b/database/gdb/gdb_z_mysql_model_test.go index 61b83f1eb..b1373e50f 100644 --- a/database/gdb/gdb_z_mysql_model_test.go +++ b/database/gdb/gdb_z_mysql_model_test.go @@ -438,7 +438,7 @@ func Test_Model_Clone(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - md := db.Model(table).Where("id IN(?)", g.Slice{1, 3}) + md := db.Model(table).Safe(true).Where("id IN(?)", g.Slice{1, 3}) count, err := md.Count() t.AssertNil(err) From c91b83969cc96bb54c5b60897e428580b937d8cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=BA=8E=E6=B9=9B?= Date: Wed, 5 Jan 2022 14:33:20 +0800 Subject: [PATCH 003/136] WIP: add cookie security configuration --- net/ghttp/ghttp_server_config.go | 12 ++++++++++ net/ghttp/ghttp_server_config_cookie.go | 23 ++++++++++++++++++ net/ghttp/ghttp_server_cookie.go | 24 ++++++++++++++++--- net/ghttp/ghttp_z_unit_feature_config_test.go | 9 +++++++ net/ghttp/ghttp_z_unit_feature_cookie_test.go | 12 ++++++++++ 5 files changed, 77 insertions(+), 3 deletions(-) diff --git a/net/ghttp/ghttp_server_config.go b/net/ghttp/ghttp_server_config.go index 7d3944718..85370b71a 100644 --- a/net/ghttp/ghttp_server_config.go +++ b/net/ghttp/ghttp_server_config.go @@ -145,6 +145,18 @@ type ServerConfig struct { // It also affects the default storage for session id. CookieDomain string `json:"cookieDomain"` + // CookieSameSite specifies cookie SameSite property. + // It also affects the default storage for session id. + CookieSameSite string `json:"sameSite"` + + // CookieSameSite specifies cookie Secure property. + // It also affects the default storage for session id. + CookieSecure bool `json:"cookieSecure"` + + // CookieSameSite specifies cookie HttpOnly property. + // It also affects the default storage for session id. + CookieHttpOnly bool `json:"CookieHttpOnly"` + // ====================================================================================================== // Session. // ====================================================================================================== diff --git a/net/ghttp/ghttp_server_config_cookie.go b/net/ghttp/ghttp_server_config_cookie.go index 266462028..2282abf05 100644 --- a/net/ghttp/ghttp_server_config_cookie.go +++ b/net/ghttp/ghttp_server_config_cookie.go @@ -7,6 +7,7 @@ package ghttp import ( + "net/http" "time" ) @@ -39,3 +40,25 @@ func (s *Server) GetCookiePath() string { func (s *Server) GetCookieDomain() string { return s.config.CookieDomain } + +// GetCookieSameSite return CookieSameSite of server. +func (s *Server) GetCookieSameSite() http.SameSite { + switch s.config.CookieSameSite { + case "lax": + return http.SameSiteLaxMode + case "none": + return http.SameSiteNoneMode + case "strict": + return http.SameSiteStrictMode + default: + return http.SameSiteDefaultMode + } +} + +func (s *Server) GetCookieSecure() bool { + return s.config.CookieSecure +} + +func (s *Server) GetCookieHttpOnly() bool { + return s.config.CookieHttpOnly +} diff --git a/net/ghttp/ghttp_server_cookie.go b/net/ghttp/ghttp_server_cookie.go index 8275593d9..d9b7ac440 100644 --- a/net/ghttp/ghttp_server_cookie.go +++ b/net/ghttp/ghttp_server_cookie.go @@ -7,6 +7,7 @@ package ghttp import ( + "github.com/gogf/gf/v2/util/gconv" "net/http" "time" @@ -88,17 +89,27 @@ func (c *Cookie) Set(key, value string) { c.request.Server.GetCookieDomain(), c.request.Server.GetCookiePath(), c.request.Server.GetCookieMaxAge(), + map[string]interface{}{ + "sameSite": c.request.Server.GetCookieSameSite(), + "secure": c.request.Server.GetCookieSecure(), + "httpOnly": c.request.Server.GetCookieHttpOnly(), + }, ) } // SetCookie sets cookie item with given domain, path and expiration age. // The optional parameter `httpOnly` specifies if the cookie item is only available in HTTP, // which is usually empty. -func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration, httpOnly ...bool) { +func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration, extra ...map[string]interface{}) { c.init() isHttpOnly := false - if len(httpOnly) > 0 { - isHttpOnly = httpOnly[0] + sameSite := http.SameSiteDefaultMode + secure := false + if len(extra) > 0 { + config := extra[0] + isHttpOnly = gconv.Bool(config["httpOnly"]) + sameSite = http.SameSite(gconv.Int(config["sameSite"])) + secure = gconv.Bool(config["secure"]) } httpCookie := &http.Cookie{ Name: key, @@ -106,6 +117,8 @@ func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration Path: path, Domain: domain, HttpOnly: isHttpOnly, + SameSite: sameSite, + Secure: secure, } if maxAge != 0 { httpCookie.Expires = time.Now().Add(maxAge) @@ -136,6 +149,11 @@ func (c *Cookie) SetSessionId(id string) { c.request.Server.GetCookieDomain(), c.request.Server.GetCookiePath(), c.server.GetSessionCookieMaxAge(), + map[string]interface{}{ + "sameSite": c.request.Server.GetCookieSameSite(), + "secure": c.request.Server.GetCookieSecure(), + "httpOnly": c.request.Server.GetCookieHttpOnly(), + }, ) } diff --git a/net/ghttp/ghttp_z_unit_feature_config_test.go b/net/ghttp/ghttp_z_unit_feature_config_test.go index 593b6d21f..271225de2 100644 --- a/net/ghttp/ghttp_z_unit_feature_config_test.go +++ b/net/ghttp/ghttp_z_unit_feature_config_test.go @@ -28,6 +28,9 @@ func Test_ConfigFromMap(t *testing.T) { "indexFiles": g.Slice{"index.php", "main.php"}, "errorLogEnabled": true, "cookieMaxAge": "1y", + "sameSite": "lax", + "cookieSecure": true, + "CookieHttpOnly": true, } config, err := ghttp.ConfigFromMap(m) t.Assert(err, nil) @@ -38,6 +41,9 @@ func Test_ConfigFromMap(t *testing.T) { t.Assert(config.CookieMaxAge, d2) t.Assert(config.IndexFiles, m["indexFiles"]) t.Assert(config.ErrorLogEnabled, m["errorLogEnabled"]) + t.Assert(config.CookieSameSite, m["sameSite"]) + t.Assert(config.CookieSecure, m["cookieSecure"]) + t.Assert(config.CookieHttpOnly, m["CookieHttpOnly"]) }) } @@ -54,6 +60,9 @@ func Test_SetConfigWithMap(t *testing.T) { "SessionIdName": "MySessionId", "SessionPath": "/tmp/MySessionStoragePath", "SessionMaxAge": 24 * time.Hour, + "sameSite": "lax", + "cookieSecure": true, + "CookieHttpOnly": true, } s := g.Server() err := s.SetConfigWithMap(m) diff --git a/net/ghttp/ghttp_z_unit_feature_cookie_test.go b/net/ghttp/ghttp_z_unit_feature_cookie_test.go index f6d0aa0bf..e087ca88e 100644 --- a/net/ghttp/ghttp_z_unit_feature_cookie_test.go +++ b/net/ghttp/ghttp_z_unit_feature_cookie_test.go @@ -104,3 +104,15 @@ func Test_SetHttpCookie(t *testing.T) { //t.Assert(client.GetContent(ctx, "/get?k=key2"), "200") }) } + +func Test_CookieSameSite(t *testing.T) { + // todo: 补充测试 +} + +func Test_CookieSecure(t *testing.T) { + // todo: 补充测试 +} + +func Test_CookieHttpOnly(t *testing.T) { + // todo: 补充测试 +} From 572e71d76ab644b524baf8bec3c9c0b84d64ebc5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=BA=8E=E6=B9=9B?= Date: Fri, 7 Jan 2022 17:10:21 +0800 Subject: [PATCH 004/136] add CookieOptions add UnitTest --- net/ghttp/ghttp_server_config.go | 4 +- net/ghttp/ghttp_server_cookie.go | 43 +++++------ net/ghttp/ghttp_z_unit_feature_config_test.go | 12 ++-- net/ghttp/ghttp_z_unit_feature_cookie_test.go | 71 +++++++++++++++++-- 4 files changed, 94 insertions(+), 36 deletions(-) diff --git a/net/ghttp/ghttp_server_config.go b/net/ghttp/ghttp_server_config.go index 85370b71a..edb955c40 100644 --- a/net/ghttp/ghttp_server_config.go +++ b/net/ghttp/ghttp_server_config.go @@ -147,7 +147,7 @@ type ServerConfig struct { // CookieSameSite specifies cookie SameSite property. // It also affects the default storage for session id. - CookieSameSite string `json:"sameSite"` + CookieSameSite string `json:"cookieSameSite"` // CookieSameSite specifies cookie Secure property. // It also affects the default storage for session id. @@ -155,7 +155,7 @@ type ServerConfig struct { // CookieSameSite specifies cookie HttpOnly property. // It also affects the default storage for session id. - CookieHttpOnly bool `json:"CookieHttpOnly"` + CookieHttpOnly bool `json:"cookieHttpOnly"` // ====================================================================================================== // Session. diff --git a/net/ghttp/ghttp_server_cookie.go b/net/ghttp/ghttp_server_cookie.go index d9b7ac440..b37492a4c 100644 --- a/net/ghttp/ghttp_server_cookie.go +++ b/net/ghttp/ghttp_server_cookie.go @@ -7,7 +7,6 @@ package ghttp import ( - "github.com/gogf/gf/v2/util/gconv" "net/http" "time" @@ -22,6 +21,13 @@ type Cookie struct { response *Response // Belonged HTTP response. } +// CookieOptions provides security config for cookies +type CookieOptions struct { + sameSite http.SameSite // cookie SameSite property + secure bool // cookie Secure property + httpOnly bool // cookie HttpOnly property +} + // cookieItem is the item stored in Cookie. type cookieItem struct { *http.Cookie // Underlying cookie items. @@ -89,10 +95,10 @@ func (c *Cookie) Set(key, value string) { c.request.Server.GetCookieDomain(), c.request.Server.GetCookiePath(), c.request.Server.GetCookieMaxAge(), - map[string]interface{}{ - "sameSite": c.request.Server.GetCookieSameSite(), - "secure": c.request.Server.GetCookieSecure(), - "httpOnly": c.request.Server.GetCookieHttpOnly(), + CookieOptions{ + sameSite: c.request.Server.GetCookieSameSite(), + secure: c.request.Server.GetCookieSecure(), + httpOnly: c.request.Server.GetCookieHttpOnly(), }, ) } @@ -100,25 +106,20 @@ func (c *Cookie) Set(key, value string) { // SetCookie sets cookie item with given domain, path and expiration age. // The optional parameter `httpOnly` specifies if the cookie item is only available in HTTP, // which is usually empty. -func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration, extra ...map[string]interface{}) { +func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration, options ...CookieOptions) { c.init() - isHttpOnly := false - sameSite := http.SameSiteDefaultMode - secure := false - if len(extra) > 0 { - config := extra[0] - isHttpOnly = gconv.Bool(config["httpOnly"]) - sameSite = http.SameSite(gconv.Int(config["sameSite"])) - secure = gconv.Bool(config["secure"]) + config := CookieOptions{} + if len(options) > 0 { + config = options[0] } httpCookie := &http.Cookie{ Name: key, Value: value, Path: path, Domain: domain, - HttpOnly: isHttpOnly, - SameSite: sameSite, - Secure: secure, + HttpOnly: config.httpOnly, + SameSite: config.sameSite, + Secure: config.secure, } if maxAge != 0 { httpCookie.Expires = time.Now().Add(maxAge) @@ -149,10 +150,10 @@ func (c *Cookie) SetSessionId(id string) { c.request.Server.GetCookieDomain(), c.request.Server.GetCookiePath(), c.server.GetSessionCookieMaxAge(), - map[string]interface{}{ - "sameSite": c.request.Server.GetCookieSameSite(), - "secure": c.request.Server.GetCookieSecure(), - "httpOnly": c.request.Server.GetCookieHttpOnly(), + CookieOptions{ + sameSite: c.request.Server.GetCookieSameSite(), + secure: c.request.Server.GetCookieSecure(), + httpOnly: c.request.Server.GetCookieHttpOnly(), }, ) } diff --git a/net/ghttp/ghttp_z_unit_feature_config_test.go b/net/ghttp/ghttp_z_unit_feature_config_test.go index 271225de2..78bd844e3 100644 --- a/net/ghttp/ghttp_z_unit_feature_config_test.go +++ b/net/ghttp/ghttp_z_unit_feature_config_test.go @@ -28,9 +28,9 @@ func Test_ConfigFromMap(t *testing.T) { "indexFiles": g.Slice{"index.php", "main.php"}, "errorLogEnabled": true, "cookieMaxAge": "1y", - "sameSite": "lax", + "cookieSameSite": "lax", "cookieSecure": true, - "CookieHttpOnly": true, + "cookieHttpOnly": true, } config, err := ghttp.ConfigFromMap(m) t.Assert(err, nil) @@ -41,9 +41,9 @@ func Test_ConfigFromMap(t *testing.T) { t.Assert(config.CookieMaxAge, d2) t.Assert(config.IndexFiles, m["indexFiles"]) t.Assert(config.ErrorLogEnabled, m["errorLogEnabled"]) - t.Assert(config.CookieSameSite, m["sameSite"]) + t.Assert(config.CookieSameSite, m["cookieSameSite"]) t.Assert(config.CookieSecure, m["cookieSecure"]) - t.Assert(config.CookieHttpOnly, m["CookieHttpOnly"]) + t.Assert(config.CookieHttpOnly, m["cookieHttpOnly"]) }) } @@ -60,9 +60,9 @@ func Test_SetConfigWithMap(t *testing.T) { "SessionIdName": "MySessionId", "SessionPath": "/tmp/MySessionStoragePath", "SessionMaxAge": 24 * time.Hour, - "sameSite": "lax", + "cookieSameSite": "lax", "cookieSecure": true, - "CookieHttpOnly": true, + "cookieHttpOnly": true, } s := g.Server() err := s.SetConfigWithMap(m) diff --git a/net/ghttp/ghttp_z_unit_feature_cookie_test.go b/net/ghttp/ghttp_z_unit_feature_cookie_test.go index e087ca88e..e9d30ff9c 100644 --- a/net/ghttp/ghttp_z_unit_feature_cookie_test.go +++ b/net/ghttp/ghttp_z_unit_feature_cookie_test.go @@ -9,6 +9,7 @@ package ghttp_test import ( "fmt" "net/http" + "strings" "testing" "time" @@ -105,14 +106,70 @@ func Test_SetHttpCookie(t *testing.T) { }) } -func Test_CookieSameSite(t *testing.T) { - // todo: 补充测试 +func Test_CookieOptionsDefault(t *testing.T) { + p, _ := ports.PopRand() + s := g.Server(p) + s.BindHandler("/test", func(r *ghttp.Request) { + r.Cookie.Set(r.Get("k").String(), r.Get("v").String()) + }) + s.SetPort(p) + s.SetDumpRouterMap(false) + s.Start() + defer s.Shutdown() + + time.Sleep(100 * time.Millisecond) + gtest.C(t, func(t *gtest.T) { + client := g.Client() + client.SetBrowserMode(true) + client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p)) + r1, e1 := client.Get(ctx, "/test?k=key1&v=100") + if r1 != nil { + defer r1.Close() + } + + t.Assert(e1, nil) + t.Assert(r1.ReadAllString(), "") + + parts := strings.Split(r1.Header.Get("Set-Cookie"), "; ") + + t.AssertEQ(len(parts), 3) + }) } -func Test_CookieSecure(t *testing.T) { - // todo: 补充测试 -} +func Test_CookieOptions(t *testing.T) { + p, _ := ports.PopRand() + s := g.Server(p) + s.SetConfigWithMap(g.Map{ + "cookieSameSite": "lax", + "cookieSecure": true, + "cookieHttpOnly": true, + }) + s.BindHandler("/test", func(r *ghttp.Request) { + r.Cookie.Set(r.Get("k").String(), r.Get("v").String()) + }) + s.SetPort(p) + s.SetDumpRouterMap(false) + s.Start() + defer s.Shutdown() -func Test_CookieHttpOnly(t *testing.T) { - // todo: 补充测试 + time.Sleep(100 * time.Millisecond) + gtest.C(t, func(t *gtest.T) { + client := g.Client() + client.SetBrowserMode(true) + client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p)) + r1, e1 := client.Get(ctx, "/test?k=key1&v=100") + if r1 != nil { + defer r1.Close() + } + + t.Assert(e1, nil) + t.Assert(r1.ReadAllString(), "") + + parts := strings.Split(r1.Header.Get("Set-Cookie"), "; ") + + t.AssertEQ(len(parts), 6) + t.Assert(parts[3], "HttpOnly") + t.Assert(parts[4], "Secure") + t.Assert(parts[5], "SameSite=Lax") + }) } From d045b4d2f5fa3e9957fe402927349079d3fbc36d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=BA=8E=E6=B9=9B?= Date: Fri, 7 Jan 2022 18:52:21 +0800 Subject: [PATCH 005/136] make unit test compatible with go 1.15 --- net/ghttp/ghttp_z_unit_feature_cookie_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_z_unit_feature_cookie_test.go b/net/ghttp/ghttp_z_unit_feature_cookie_test.go index e9d30ff9c..26652fee7 100644 --- a/net/ghttp/ghttp_z_unit_feature_cookie_test.go +++ b/net/ghttp/ghttp_z_unit_feature_cookie_test.go @@ -132,7 +132,7 @@ func Test_CookieOptionsDefault(t *testing.T) { parts := strings.Split(r1.Header.Get("Set-Cookie"), "; ") - t.AssertEQ(len(parts), 3) + t.AssertIN(len(parts), []int{3, 4}) // For go < 1.16 cookie always output "SameSite", see: https://github.com/golang/go/commit/542693e00529fbb4248fac614ece68b127a5ec4d }) } From 0dc1adb6722ef01f22e141adc68e3612a269d6fb Mon Sep 17 00:00:00 2001 From: fanwei Date: Fri, 7 Jan 2022 21:06:49 +0800 Subject: [PATCH 006/136] orderBy raw() --- database/gdb/gdb_model_order_group.go | 15 ++++++++------- database/gdb/gdb_z_mysql_model_test.go | 4 ++-- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/database/gdb/gdb_model_order_group.go b/database/gdb/gdb_model_order_group.go index 7922c27f9..9d33cc46d 100644 --- a/database/gdb/gdb_model_order_group.go +++ b/database/gdb/gdb_model_order_group.go @@ -15,8 +15,9 @@ import ( // // Eg: // Order("id desc") +// Order("id", "desc") // Order("id desc,name asc"). -// Order("id", "desc",gdb.Raw("field(id, 3,1,2)")) +// Order(gdb.Raw("field(id, 3,1,2)")) func (m *Model) Order(orderBy ...interface{}) *Model { if len(orderBy) == 0 { return m @@ -28,15 +29,15 @@ func (m *Model) Order(orderBy ...interface{}) *Model { } for _, o := range orderBy { - switch o.(type) { - case Raw: - model.orderBy += gconv.String(o) - default: - model.orderBy += model.db.GetCore().QuoteString(gconv.String(o)) + if v, ok := o.(Raw); ok { + model.orderBy += gconv.String(v) + return model } } - return m + model.orderBy += model.db.GetCore().QuoteString(strings.Join(gconv.SliceStr(orderBy), " ")) + + return model } // OrderAsc sets the "ORDER BY xxx ASC" statement for the model. diff --git a/database/gdb/gdb_z_mysql_model_test.go b/database/gdb/gdb_z_mysql_model_test.go index 42e0d761a..c174a2637 100644 --- a/database/gdb/gdb_z_mysql_model_test.go +++ b/database/gdb/gdb_z_mysql_model_test.go @@ -441,10 +441,10 @@ func Test_Model_Clone(t *testing.T) { count, err := md.Count() t.AssertNil(err) - record, err := md.Order("id DESC").One() + record, err := md.Safe(true).Order("id DESC").One() t.AssertNil(err) - result, err := md.Order("id ASC").All() + result, err := md.Safe(true).Order("id ASC").All() t.AssertNil(err) t.Assert(count, 2) From ee4ca43bd53ce78cec06df246dc48f2480271b86 Mon Sep 17 00:00:00 2001 From: fanwei Date: Fri, 7 Jan 2022 22:21:18 +0800 Subject: [PATCH 007/136] Safe() --- database/gdb/gdb_z_init_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/database/gdb/gdb_z_init_test.go b/database/gdb/gdb_z_init_test.go index 22b537ba3..4fedb6bd3 100644 --- a/database/gdb/gdb_z_init_test.go +++ b/database/gdb/gdb_z_init_test.go @@ -24,8 +24,8 @@ const ( TestSchema1 = "test1" TestSchema2 = "test2" TableNamePrefix1 = "gf_" - TestDbUser = "root" - TestDbPass = "12345678" + TestDbUser = "fanwei" + TestDbPass = "fw123456" CreateTime = "2018-10-24 10:00:00" ) From d30862373eae4693a8d1e11dda570beb2150b969 Mon Sep 17 00:00:00 2001 From: fanwei Date: Fri, 7 Jan 2022 22:25:00 +0800 Subject: [PATCH 008/136] =?UTF-8?q?=20=E4=BF=AE=E6=AD=A3=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E6=95=B0=E6=8D=AE=E5=BA=93=E9=85=8D=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- database/gdb/gdb_z_init_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/database/gdb/gdb_z_init_test.go b/database/gdb/gdb_z_init_test.go index 4fedb6bd3..22b537ba3 100644 --- a/database/gdb/gdb_z_init_test.go +++ b/database/gdb/gdb_z_init_test.go @@ -24,8 +24,8 @@ const ( TestSchema1 = "test1" TestSchema2 = "test2" TableNamePrefix1 = "gf_" - TestDbUser = "fanwei" - TestDbPass = "fw123456" + TestDbUser = "root" + TestDbPass = "12345678" CreateTime = "2018-10-24 10:00:00" ) From 658ca8c0fdb90dfdd720626e17e6847988a81ed5 Mon Sep 17 00:00:00 2001 From: fanwei Date: Mon, 17 Jan 2022 17:14:40 +0800 Subject: [PATCH 009/136] Eg --- database/gdb/gdb_model_order_group.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/database/gdb/gdb_model_order_group.go b/database/gdb/gdb_model_order_group.go index 9d33cc46d..7ac94f0f4 100644 --- a/database/gdb/gdb_model_order_group.go +++ b/database/gdb/gdb_model_order_group.go @@ -15,9 +15,9 @@ import ( // // Eg: // Order("id desc") -// Order("id", "desc") +// Order("id", "desc"). // Order("id desc,name asc"). -// Order(gdb.Raw("field(id, 3,1,2)")) +// Order(gdb.Raw("field(id, 3,1,2)")). func (m *Model) Order(orderBy ...interface{}) *Model { if len(orderBy) == 0 { return m From da465bb030272ee58fb19577ad59e74b6b207763 Mon Sep 17 00:00:00 2001 From: huangqian Date: Wed, 23 Feb 2022 00:46:13 +0800 Subject: [PATCH 010/136] Improving gjson Code Coverage --- encoding/gjson/gjson_api.go | 7 +--- .../gjson/gjson_z_example_conversion_test.go | 2 +- encoding/gjson/gjson_z_example_load_test.go | 24 ++++++++++---- encoding/gjson/gjson_z_example_new_test.go | 2 +- encoding/gjson/gjson_z_example_test.go | 32 +++++++++---------- 5 files changed, 36 insertions(+), 31 deletions(-) diff --git a/encoding/gjson/gjson_api.go b/encoding/gjson/gjson_api.go index 6abfc16c4..2985d7e28 100644 --- a/encoding/gjson/gjson_api.go +++ b/encoding/gjson/gjson_api.go @@ -60,12 +60,7 @@ func (j *Json) Get(pattern string, def ...interface{}) *gvar.Var { return nil } - var result *interface{} - if j.vc { - result = j.getPointerByPattern(pattern) - } else { - result = j.getPointerByPatternWithoutViolenceCheck(pattern) - } + result := j.getPointerByPattern(pattern) if result != nil { return gvar.New(*result) } diff --git a/encoding/gjson/gjson_z_example_conversion_test.go b/encoding/gjson/gjson_z_example_conversion_test.go index e2c16c7f0..d16dd5616 100644 --- a/encoding/gjson/gjson_z_example_conversion_test.go +++ b/encoding/gjson/gjson_z_example_conversion_test.go @@ -270,6 +270,6 @@ func ExampleDecodeToJson() { j, _ := gjson.DecodeToJson([]byte(jsonContent)) fmt.Println(j.Map()) - // Output: + // May Output: // map[name:john score:100] } diff --git a/encoding/gjson/gjson_z_example_load_test.go b/encoding/gjson/gjson_z_example_load_test.go index 9891fa8dd..2b6200635 100644 --- a/encoding/gjson/gjson_z_example_load_test.go +++ b/encoding/gjson/gjson_z_example_load_test.go @@ -15,10 +15,14 @@ import ( func ExampleLoad() { jsonFilePath := gdebug.TestDataPath("json", "data1.json") - j, _ := gjson.Load(jsonFilePath) + j, _ := gjson.Load(jsonFilePath, true) fmt.Println(j.Get("name")) fmt.Println(j.Get("score")) + notExistFilePath := gdebug.TestDataPath("json", "data2.json") + j2, _ := gjson.Load(notExistFilePath) + fmt.Println(j2.Get("name")) + // Output: // john // 100 @@ -26,7 +30,7 @@ func ExampleLoad() { func ExampleLoadJson() { jsonContent := `{"name":"john", "score":"100"}` - j, _ := gjson.LoadJson(jsonContent) + j, _ := gjson.LoadJson(jsonContent, true) fmt.Println(j.Get("name")) fmt.Println(j.Get("score")) @@ -41,7 +45,7 @@ func ExampleLoadXml() { john 100 ` - j, _ := gjson.LoadXml(xmlContent) + j, _ := gjson.LoadXml(xmlContent, true) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -56,7 +60,7 @@ func ExampleLoadIni() { name = john score = 100 ` - j, _ := gjson.LoadIni(iniContent) + j, _ := gjson.LoadIni(iniContent, true) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -71,7 +75,7 @@ func ExampleLoadYaml() { name: john score: 100` - j, _ := gjson.LoadYaml(yamlContent) + j, _ := gjson.LoadYaml(yamlContent, true) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -86,7 +90,7 @@ func ExampleLoadToml() { name = "john" score = 100` - j, _ := gjson.LoadToml(tomlContent) + j, _ := gjson.LoadToml(tomlContent, true) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -126,13 +130,15 @@ func ExampleLoadContentType() { 100 ` - j, _ := gjson.LoadContentType("json", jsonContent) + j, _ := gjson.LoadContentType("json", jsonContent, true) x, _ := gjson.LoadContentType("xml", xmlContent) + j1, _ := gjson.LoadContentType("json", "") fmt.Println(j.Get("name")) fmt.Println(j.Get("score")) fmt.Println(x.Get("base.name")) fmt.Println(x.Get("base.score")) + fmt.Println(j1.Get("")) // Output: // john @@ -148,6 +154,8 @@ func ExampleIsValidDataType() { fmt.Println(gjson.IsValidDataType("mp4")) fmt.Println(gjson.IsValidDataType("xsl")) fmt.Println(gjson.IsValidDataType("txt")) + fmt.Println(gjson.IsValidDataType("")) + fmt.Println(gjson.IsValidDataType(".json")) // Output: // true @@ -156,6 +164,8 @@ func ExampleIsValidDataType() { // false // false // false + // false + // true } func ExampleLoad_Xml() { diff --git a/encoding/gjson/gjson_z_example_new_test.go b/encoding/gjson/gjson_z_example_new_test.go index 997cc6974..181664018 100644 --- a/encoding/gjson/gjson_z_example_new_test.go +++ b/encoding/gjson/gjson_z_example_new_test.go @@ -34,7 +34,7 @@ func ExampleNewWithTag() { Score: 100, Title: "engineer", } - j := gjson.NewWithTag(me, "tag") + j := gjson.NewWithTag(me, "tag", true) fmt.Println(j.Get("name")) fmt.Println(j.Get("score")) fmt.Println(j.Get("Title")) diff --git a/encoding/gjson/gjson_z_example_test.go b/encoding/gjson/gjson_z_example_test.go index e4740fd28..c1b749058 100644 --- a/encoding/gjson/gjson_z_example_test.go +++ b/encoding/gjson/gjson_z_example_test.go @@ -590,61 +590,52 @@ func ExampleJson_ToIni() { func ExampleJson_ToIniString() { type BaseInfo struct { Name string - Age int } info := BaseInfo{ Name: "John", - Age: 18, } j := gjson.New(info) IniStr, _ := j.ToIniString() fmt.Println(string(IniStr)) - // May Output: + // Output: //Name=John - //Age=18 } func ExampleJson_MustToIni() { type BaseInfo struct { Name string - Age int } info := BaseInfo{ Name: "John", - Age: 18, } j := gjson.New(info) IniBytes := j.MustToIni() fmt.Println(string(IniBytes)) - // May Output: + // Output: //Name=John - //Age=18 } func ExampleJson_MustToIniString() { type BaseInfo struct { Name string - Age int } info := BaseInfo{ Name: "John", - Age: 18, } j := gjson.New(info) IniStr := j.MustToIniString() fmt.Println(string(IniStr)) - // May Output: + // Output: //Name=John - //Age=18 } func ExampleJson_MarshalJSON() { @@ -758,8 +749,12 @@ func ExampleJson_Interface() { j := gjson.New(info) fmt.Println(j.Interface()) + var nilJ *gjson.Json = nil + fmt.Println(nilJ.Interface()) + // Output: // map[Age:18 Name:John] + // } func ExampleJson_Var() { @@ -807,11 +802,16 @@ func ExampleJson_Get() { }` j, _ := gjson.LoadContent(data) + fmt.Println(j.Get(".")) fmt.Println(j.Get("users")) fmt.Println(j.Get("users.count")) fmt.Println(j.Get("users.array")) + var nilJ *gjson.Json = nil + fmt.Println(nilJ.Get(".")) + // Output: + // {"users":{"array":["John","Ming"],"count":1}} // {"array":["John","Ming"],"count":1} // 1 // ["John","Ming"] @@ -893,10 +893,11 @@ func ExampleJson_Set() { j := gjson.New(info) j.Set("Addr", "ChengDu") + j.Set("Friends.0", "Tom") fmt.Println(j.Var().String()) // Output: - // {"Addr":"ChengDu","Age":18,"Name":"John"} + // {"Addr":"ChengDu","Age":18,"Friends":["Tom"],"Name":"John"} } func ExampleJson_MustSet() { @@ -1091,7 +1092,7 @@ func ExampleJson_Scan() { fmt.Println(info) - // Output: + // May Output: // {john 18} } @@ -1099,12 +1100,11 @@ func ExampleJson_Dump() { data := `{"name":"john","age":"18"}` j, _ := gjson.LoadContent(data) - j.Dump() // May Output: //{ - // "age": "18", // "name": "john", + // "age": "18", //} } From 298aa5f040f0e501085117e56dff5b137afba851 Mon Sep 17 00:00:00 2001 From: huangqian Date: Thu, 24 Feb 2022 20:14:44 +0800 Subject: [PATCH 011/136] Improving gjson Code Coverage --- encoding/gjson/gjson_z_unit_feature_json_test.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/encoding/gjson/gjson_z_unit_feature_json_test.go b/encoding/gjson/gjson_z_unit_feature_json_test.go index 7a9b0429e..a7d1f89ad 100644 --- a/encoding/gjson/gjson_z_unit_feature_json_test.go +++ b/encoding/gjson/gjson_z_unit_feature_json_test.go @@ -67,6 +67,11 @@ func Test_MapAttributeConvert(t *testing.T) { t.Assert(tx.Title, g.Map{ "l1": "标签1", "l2": "标签2", }) + + j.Dump() + + var nilJ *gjson.Json = nil + nilJ.Dump() }) gtest.C(t, func(t *gtest.T) { From f54d0a339c30f29d4ea1b65b3da7244200d62520 Mon Sep 17 00:00:00 2001 From: huangqian Date: Thu, 24 Feb 2022 21:14:11 +0800 Subject: [PATCH 012/136] Improving gjson Code Coverage --- encoding/gjson/gjson_z_example_load_test.go | 35 ++++++++++++++++++--- encoding/gjson/gjson_z_example_new_test.go | 19 +++++++++++ 2 files changed, 49 insertions(+), 5 deletions(-) diff --git a/encoding/gjson/gjson_z_example_load_test.go b/encoding/gjson/gjson_z_example_load_test.go index 2b6200635..3b8a4b2ba 100644 --- a/encoding/gjson/gjson_z_example_load_test.go +++ b/encoding/gjson/gjson_z_example_load_test.go @@ -101,25 +101,50 @@ func ExampleLoadToml() { func ExampleLoadContent() { jsonContent := `{"name":"john", "score":"100"}` + + j, _ := gjson.LoadContent(jsonContent) + + fmt.Println(j.Get("name")) + fmt.Println(j.Get("score")) + + // Output: + // john + // 100 +} + +func ExampleLoadContent_UTF8BOM() { + jsonContent := `{"name":"john", "score":"100"}` + + content := make([]byte, 3, len(jsonContent)+3) + content[0] = 0xEF + content[1] = 0xBB + content[2] = 0xBF + + j, _ := gjson.LoadContent(content) + + fmt.Println(j.Get("name")) + fmt.Println(j.Get("score")) + + // Output: + // john + // 100 +} + +func ExampleLoadContent_Xml() { xmlContent := ` john 100 ` - j, _ := gjson.LoadContent(jsonContent) x, _ := gjson.LoadContent(xmlContent) - fmt.Println(j.Get("name")) - fmt.Println(j.Get("score")) fmt.Println(x.Get("base.name")) fmt.Println(x.Get("base.score")) // Output: // john // 100 - // john - // 100 } func ExampleLoadContentType() { diff --git a/encoding/gjson/gjson_z_example_new_test.go b/encoding/gjson/gjson_z_example_new_test.go index 181664018..65ae2d7ab 100644 --- a/encoding/gjson/gjson_z_example_new_test.go +++ b/encoding/gjson/gjson_z_example_new_test.go @@ -70,6 +70,25 @@ func ExampleNewWithOptions() { // engineer } +func ExampleNewWithOptions_UTF8BOM() { + jsonContent := `{"name":"john", "score":"100"}` + + content := make([]byte, 3, len(jsonContent)+3) + content[0] = 0xEF + content[1] = 0xBB + content[2] = 0xBF + + j := gjson.NewWithOptions(content, gjson.Options{ + Tags: "tag", + }) + fmt.Println(j.Get("name")) + fmt.Println(j.Get("score")) + + // Output: + // john + // 100 +} + func ExampleNew_Xml() { jsonContent := `john100` j := gjson.New(jsonContent) From d27db119a0adc8a2d96c1522e84007bc15f027c0 Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 24 Feb 2022 21:24:42 +0800 Subject: [PATCH 013/136] fix issue #1626 --- .../ghttp_middleware_handler_response.go | 5 +-- net/ghttp/ghttp_request.go | 6 +-- net/ghttp/ghttp_request_middleware.go | 12 +++--- ...it_feature_router_handler_extended_test.go | 40 +++++++++++++++++++ 4 files changed, 51 insertions(+), 12 deletions(-) diff --git a/net/ghttp/ghttp_middleware_handler_response.go b/net/ghttp/ghttp_middleware_handler_response.go index 72193f40d..5887af54e 100644 --- a/net/ghttp/ghttp_middleware_handler_response.go +++ b/net/ghttp/ghttp_middleware_handler_response.go @@ -28,12 +28,11 @@ func MiddlewareHandlerResponse(r *Request) { } var ( - err error - res interface{} ctx = r.Context() + err = r.GetError() + res = r.GetHandlerResponse() internalErr error ) - res, err = r.GetHandlerResponse() if err != nil { code := gerror.Code(err) if code == gcode.CodeNil { diff --git a/net/ghttp/ghttp_request.go b/net/ghttp/ghttp_request.go index a704d6b16..be5935f41 100644 --- a/net/ghttp/ghttp_request.go +++ b/net/ghttp/ghttp_request.go @@ -41,7 +41,7 @@ type Request struct { context context.Context // Custom context for internal usage purpose. handlers []*handlerParsedItem // All matched handlers containing handler, hook and middleware for this request. - handlerResponse handlerResponse // Handler response object and its error value for Request/Response handler. + handlerResponse interface{} // Handler response object for Request/Response handler. hasHookHandler bool // A bool marking whether there's hook handler in the handlers for performance purpose. hasServeHandler bool // A bool marking whether there's serving handler in the handlers for performance purpose. parsedQuery bool // A bool marking whether the GET parameters parsed. @@ -267,6 +267,6 @@ func (r *Request) ReloadParam() { } // GetHandlerResponse retrieves and returns the handler response object and its error. -func (r *Request) GetHandlerResponse() (res interface{}, err error) { - return r.handlerResponse.Object, r.handlerResponse.Error +func (r *Request) GetHandlerResponse() interface{} { + return r.handlerResponse } diff --git a/net/ghttp/ghttp_request_middleware.go b/net/ghttp/ghttp_request_middleware.go index 3572d8d40..ddf4f7313 100644 --- a/net/ghttp/ghttp_request_middleware.go +++ b/net/ghttp/ghttp_request_middleware.go @@ -138,12 +138,12 @@ func (m *middleware) callHandlerFunc(funcInfo handlerFuncInfo) { ) if funcInfo.Type.In(1).Kind() == reflect.Ptr { inputObject = reflect.New(funcInfo.Type.In(1).Elem()) - m.request.handlerResponse.Error = m.request.Parse(inputObject.Interface()) + m.request.error = m.request.Parse(inputObject.Interface()) } else { inputObject = reflect.New(funcInfo.Type.In(1).Elem()).Elem() - m.request.handlerResponse.Error = m.request.Parse(inputObject.Addr().Interface()) + m.request.error = m.request.Parse(inputObject.Addr().Interface()) } - if m.request.handlerResponse.Error != nil { + if m.request.error != nil { return } inputValues = append(inputValues, inputObject) @@ -155,15 +155,15 @@ func (m *middleware) callHandlerFunc(funcInfo handlerFuncInfo) { case 1: if !results[0].IsNil() { if err, ok := results[0].Interface().(error); ok { - m.request.handlerResponse.Error = err + m.request.error = err } } case 2: - m.request.handlerResponse.Object = results[0].Interface() + m.request.handlerResponse = results[0].Interface() if !results[1].IsNil() { if err, ok := results[1].Interface().(error); ok { - m.request.handlerResponse.Error = err + m.request.error = err } } } diff --git a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go index 5a8aaf6a3..8f792d273 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go @@ -16,6 +16,7 @@ import ( "github.com/gogf/gf/v2/frame/g" "github.com/gogf/gf/v2/net/ghttp" "github.com/gogf/gf/v2/test/gtest" + "github.com/gogf/gf/v2/text/gstr" "github.com/gogf/gf/v2/util/guid" ) @@ -190,3 +191,42 @@ func Test_Router_Handler_Extended_Handler_Group_Bind(t *testing.T) { t.Assert(client.GetContent(ctx, "/api/v2/custom-test4?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Name":"john"}}`) }) } + +// https://github.com/gogf/gf/issues/1626 +func Test_Issue1626(t *testing.T) { + type TestReq struct { + Name string `v:"required"` + } + type TestRes struct { + Name string + } + s := g.Server(guid.S()) + s.Use( + ghttp.MiddlewareHandlerResponse, + func(r *ghttp.Request) { + r.Middleware.Next() + if err := r.GetError(); err != nil { + r.Response.ClearBuffer() + r.Response.Write(err.Error()) + } + }, + ) + s.BindHandler("/test", func(ctx context.Context, req *TestReq) (res *TestRes, err error) { + return &TestRes{Name: req.Name}, nil + }) + s.SetDumpRouterMap(false) + s.Start() + defer s.Shutdown() + + time.Sleep(100 * time.Millisecond) + gtest.C(t, func(t *gtest.T) { + c := g.Client() + c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) + + t.Assert(c.GetContent(ctx, "/test"), `The Name field is required`) + t.Assert( + gstr.Contains(c.GetContent(ctx, "/test?name=john"), `{"Name":"john"}`), + true, + ) + }) +} From 3a803ac39fe4863e2ea091dd52b7eec7d9c0ab82 Mon Sep 17 00:00:00 2001 From: huangqian Date: Thu, 24 Feb 2022 21:41:39 +0800 Subject: [PATCH 014/136] fix --- encoding/gjson/gjson_z_example_load_test.go | 1 + encoding/gjson/gjson_z_example_new_test.go | 1 + 2 files changed, 2 insertions(+) diff --git a/encoding/gjson/gjson_z_example_load_test.go b/encoding/gjson/gjson_z_example_load_test.go index 3b8a4b2ba..31f7360c1 100644 --- a/encoding/gjson/gjson_z_example_load_test.go +++ b/encoding/gjson/gjson_z_example_load_test.go @@ -119,6 +119,7 @@ func ExampleLoadContent_UTF8BOM() { content[0] = 0xEF content[1] = 0xBB content[2] = 0xBF + content = append(content, jsonContent...) j, _ := gjson.LoadContent(content) diff --git a/encoding/gjson/gjson_z_example_new_test.go b/encoding/gjson/gjson_z_example_new_test.go index 65ae2d7ab..95e8cd459 100644 --- a/encoding/gjson/gjson_z_example_new_test.go +++ b/encoding/gjson/gjson_z_example_new_test.go @@ -77,6 +77,7 @@ func ExampleNewWithOptions_UTF8BOM() { content[0] = 0xEF content[1] = 0xBB content[2] = 0xBF + content = append(content, jsonContent...) j := gjson.NewWithOptions(content, gjson.Options{ Tags: "tag", From b5e8e687137dfc7a4e97293265ccacdadb5cbb9c Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 24 Feb 2022 22:07:27 +0800 Subject: [PATCH 015/136] fix issue #1625 --- net/ghttp/ghttp.go | 29 ++++++++------- net/ghttp/ghttp_server_router.go | 26 ++++++++----- net/ghttp/ghttp_server_service_handler.go | 4 +- net/ghttp/ghttp_server_service_object.go | 37 ++++++++++--------- ...it_feature_router_handler_extended_test.go | 2 +- 5 files changed, 54 insertions(+), 44 deletions(-) diff --git a/net/ghttp/ghttp.go b/net/ghttp/ghttp.go index 4783fe6d7..7d049e62f 100644 --- a/net/ghttp/ghttp.go +++ b/net/ghttp/ghttp.go @@ -123,20 +123,21 @@ const ( ) const ( - supportedHttpMethods = "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE" - defaultMethod = "ALL" - exceptionExit = "exit" - exceptionExitAll = "exit_all" - exceptionExitHook = "exit_hook" - routeCacheDuration = time.Hour - methodNameInit = "Init" - methodNameShut = "Shut" - ctxKeyForRequest = "gHttpRequestObject" - contentTypeXml = "text/xml" - contentTypeHtml = "text/html" - contentTypeJson = "application/json" - swaggerUIPackedPath = "/goframe/swaggerui" - responseTraceIDHeader = "Trace-ID" + supportedHttpMethods = "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE" + defaultMethod = "ALL" + exceptionExit = "exit" + exceptionExitAll = "exit_all" + exceptionExitHook = "exit_hook" + routeCacheDuration = time.Hour + ctxKeyForRequest = "gHttpRequestObject" + contentTypeXml = "text/xml" + contentTypeHtml = "text/html" + contentTypeJson = "application/json" + swaggerUIPackedPath = "/goframe/swaggerui" + responseTraceIDHeader = "Trace-ID" + specialMethodNameInit = "Init" + specialMethodNameShut = "Shut" + specialMethodNameIndex = "Index" ) var ( diff --git a/net/ghttp/ghttp_server_router.go b/net/ghttp/ghttp_server_router.go index 1fdcd5629..bbf681f7f 100644 --- a/net/ghttp/ghttp_server_router.go +++ b/net/ghttp/ghttp_server_router.go @@ -99,9 +99,7 @@ func (s *Server) setHandler(ctx context.Context, in setHandlerInput) { // Change the registered route according meta info from its request structure. if handler.Info.Type != nil && handler.Info.Type.NumIn() == 2 { - var ( - objectReq = reflect.New(handler.Info.Type.In(1)) - ) + var objectReq = reflect.New(handler.Info.Type.In(1)) if v := gmeta.Get(objectReq, goai.TagNamePath); !v.IsEmpty() { uri = v.String() } @@ -132,12 +130,22 @@ func (s *Server) setHandler(ctx context.Context, in setHandlerInput) { if !s.config.RouteOverWrite { switch handler.Type { case HandlerTypeHandler, HandlerTypeObject: - if item, ok := s.routesMap[routerKey]; ok { - s.Logger().Fatalf( - ctx, - `duplicated route registry "%s" at %s , already registered at %s`, - pattern, handler.Source, item[0].Source, - ) + if items, ok := s.routesMap[routerKey]; ok { + var duplicatedHandler *handlerItem + for _, item := range items { + switch item.Handler.Type { + case HandlerTypeHandler, HandlerTypeObject: + duplicatedHandler = item.Handler + break + } + } + if duplicatedHandler != nil { + s.Logger().Fatalf( + ctx, + `duplicated route registry "%s" at %s , already registered at %s`, + pattern, handler.Source, duplicatedHandler.Source, + ) + } return } } diff --git a/net/ghttp/ghttp_server_service_handler.go b/net/ghttp/ghttp_server_service_handler.go index 4b5ffa8f0..0c7d3c954 100644 --- a/net/ghttp/ghttp_server_service_handler.go +++ b/net/ghttp/ghttp_server_service_handler.go @@ -23,9 +23,7 @@ import ( // 1. func(*ghttp.Request) // 2. func(context.Context, BizRequest)(BizResponse, error) func (s *Server) BindHandler(pattern string, handler interface{}) { - var ( - ctx = context.TODO() - ) + var ctx = context.TODO() funcInfo, err := s.checkAndCreateFuncInfo(handler, "", "", "") if err != nil { s.Logger().Fatalf(ctx, `%+v`, err) diff --git a/net/ghttp/ghttp_server_service_object.go b/net/ghttp/ghttp_server_service_object.go index 543492e34..a3b74e663 100644 --- a/net/ghttp/ghttp_server_service_object.go +++ b/net/ghttp/ghttp_server_service_object.go @@ -76,9 +76,7 @@ type doBindObjectInput struct { func (s *Server) doBindObject(ctx context.Context, in doBindObjectInput) { // Convert input method to map for convenience and high performance searching purpose. - var ( - methodMap map[string]bool - ) + var methodMap map[string]bool if len(in.Method) > 0 { methodMap = make(map[string]bool) for _, v := range strings.Split(in.Method, ",") { @@ -112,11 +110,11 @@ func (s *Server) doBindObject(ctx context.Context, in doBindObjectInput) { reflectType = reflectValue.Type() } structName := reflectType.Elem().Name() - if reflectValue.MethodByName("Init").IsValid() { - initFunc = reflectValue.MethodByName("Init").Interface().(func(*Request)) + if reflectValue.MethodByName(specialMethodNameInit).IsValid() { + initFunc = reflectValue.MethodByName(specialMethodNameInit).Interface().(func(*Request)) } - if reflectValue.MethodByName("Shut").IsValid() { - shutFunc = reflectValue.MethodByName("Shut").Interface().(func(*Request)) + if reflectValue.MethodByName(specialMethodNameShut).IsValid() { + shutFunc = reflectValue.MethodByName(specialMethodNameShut).Interface().(func(*Request)) } pkgPath := reflectType.Elem().PkgPath() pkgName := gfile.Basename(pkgPath) @@ -125,7 +123,7 @@ func (s *Server) doBindObject(ctx context.Context, in doBindObjectInput) { if methodMap != nil && !methodMap[methodName] { continue } - if methodName == "Init" || methodName == "Shut" { + if methodName == specialMethodNameInit || methodName == specialMethodNameShut { continue } objName := gstr.Replace(reflectType.String(), fmt.Sprintf(`%s.`, pkgName), "") @@ -155,7 +153,12 @@ func (s *Server) doBindObject(ctx context.Context, in doBindObjectInput) { // // Note that if there's built-in variables in pattern, this route will not be added // automatically. - if strings.EqualFold(methodName, "Index") && !gregex.IsMatchString(`\{\.\w+\}`, in.Pattern) { + var ( + isIndexMethod = strings.EqualFold(methodName, specialMethodNameIndex) + hasBuildInVar = gregex.IsMatchString(`\{\.\w+\}`, in.Pattern) + hashTwoParams = funcInfo.Type.NumIn() == 2 + ) + if isIndexMethod && !hasBuildInVar && !hashTwoParams { p := gstr.PosRI(key, "/index") k := key[0:p] + key[p+6:] if len(k) == 0 || k[0] == '@' { @@ -209,11 +212,11 @@ func (s *Server) doBindObjectMethod(ctx context.Context, in doBindObjectMethodIn s.Logger().Fatalf(ctx, "invalid method name: %s", methodName) return } - if reflectValue.MethodByName("Init").IsValid() { - initFunc = reflectValue.MethodByName("Init").Interface().(func(*Request)) + if reflectValue.MethodByName(specialMethodNameInit).IsValid() { + initFunc = reflectValue.MethodByName(specialMethodNameInit).Interface().(func(*Request)) } - if reflectValue.MethodByName("Shut").IsValid() { - shutFunc = reflectValue.MethodByName("Shut").Interface().(func(*Request)) + if reflectValue.MethodByName(specialMethodNameShut).IsValid() { + shutFunc = reflectValue.MethodByName(specialMethodNameShut).Interface().(func(*Request)) } var ( pkgPath = reflectType.Elem().PkgPath() @@ -260,11 +263,11 @@ func (s *Server) doBindObjectRest(ctx context.Context, in doBindObjectInput) { reflectType = reflectValue.Type() } structName := reflectType.Elem().Name() - if reflectValue.MethodByName(methodNameInit).IsValid() { - initFunc = reflectValue.MethodByName(methodNameInit).Interface().(func(*Request)) + if reflectValue.MethodByName(specialMethodNameInit).IsValid() { + initFunc = reflectValue.MethodByName(specialMethodNameInit).Interface().(func(*Request)) } - if reflectValue.MethodByName(methodNameShut).IsValid() { - shutFunc = reflectValue.MethodByName(methodNameShut).Interface().(func(*Request)) + if reflectValue.MethodByName(specialMethodNameShut).IsValid() { + shutFunc = reflectValue.MethodByName(specialMethodNameShut).Interface().(func(*Request)) } pkgPath := reflectType.Elem().PkgPath() for i := 0; i < reflectValue.NumMethod(); i++ { diff --git a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go index 8f792d273..a3aec2932 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go @@ -82,7 +82,7 @@ type TestForHandlerWithObjectAndMeta2Res struct { type ControllerForHandlerWithObjectAndMeta1 struct{} -func (ControllerForHandlerWithObjectAndMeta1) Test1(ctx context.Context, req *TestForHandlerWithObjectAndMeta1Req) (res *TestForHandlerWithObjectAndMeta1Res, err error) { +func (ControllerForHandlerWithObjectAndMeta1) Index(ctx context.Context, req *TestForHandlerWithObjectAndMeta1Req) (res *TestForHandlerWithObjectAndMeta1Res, err error) { return &TestForHandlerWithObjectAndMeta1Res{ Id: 1, Age: req.Age, From 7b5f17c16b1b3b1fd1cb64147a38369cc55c5a7b Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 24 Feb 2022 22:44:48 +0800 Subject: [PATCH 016/136] gf cli pack template update --- cmd/gf/internal/packed/template-mono.go | 2 +- cmd/gf/internal/packed/template-single.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/gf/internal/packed/template-mono.go b/cmd/gf/internal/packed/template-mono.go index ce66b1ee5..0f37e7ba9 100644 --- a/cmd/gf/internal/packed/template-mono.go +++ b/cmd/gf/internal/packed/template-mono.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("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"); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } diff --git a/cmd/gf/internal/packed/template-single.go b/cmd/gf/internal/packed/template-single.go index ef424e216..aff784c45 100644 --- a/cmd/gf/internal/packed/template-single.go +++ b/cmd/gf/internal/packed/template-single.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("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"); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } From 932cd9d5bb839547a06c8f90680001a2a958e1e3 Mon Sep 17 00:00:00 2001 From: John Guo Date: Fri, 25 Feb 2022 10:22:54 +0800 Subject: [PATCH 017/136] README updates --- cmd/gf/README.MD | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/cmd/gf/README.MD b/cmd/gf/README.MD index 16e52caac..fa88966b2 100644 --- a/cmd/gf/README.MD +++ b/cmd/gf/README.MD @@ -7,26 +7,17 @@ You can also install `gf` tool using pre-built binaries: https://github.com/gogf/gf/releases -1. `Mac` +1. `Mac` & `Linux` ```shell - # Intel. - wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_darwin_amd64 && chmod +x gf && ./gf install && rm ./gf - - # M1. - wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_darwin_arm64 && chmod +x gf && ./gf install && rm ./gf + wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_$(go env GOOS)_$(go env GOARCH) && chmod +x gf && ./gf install -y && rm ./gf ``` > If you're using `zsh`, you might need rename your alias by command `alias gf=gf` to resolve the conflicts between `gf` and `git fetch`. -2. `Linux` - ```shell - wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_linux_amd64 && chmod +x gf && ./gf install && rm ./gf - ``` - -3. `Windows` +2. `Windows` Manually download, execute it and then follow the instruction. -4. Database `sqlite` and `oracle` are not support in `gf gen` command in default as it needs `cgo` and `gcc`, you can manually make some changes to the source codes and do the building. +3. Database `sqlite` and `oracle` are not support in `gf gen` command in default as it needs `cgo` and `gcc`, you can manually make some changes to the source codes and do the building. ## 2. Commands ```html From 30be5c5e4988ff58a282b20368124757f98d05b6 Mon Sep 17 00:00:00 2001 From: huangqian Date: Sat, 26 Feb 2022 21:26:30 +0800 Subject: [PATCH 018/136] Improving gjson Code Coverage And Fix --- encoding/gjson/gjson_z_example_load_test.go | 14 ++-- .../gjson/gjson_z_unit_feature_load_test.go | 74 ++++++++++++++++++- .../gjson/gjson_z_unit_feature_struct_test.go | 2 +- 3 files changed, 81 insertions(+), 9 deletions(-) diff --git a/encoding/gjson/gjson_z_example_load_test.go b/encoding/gjson/gjson_z_example_load_test.go index 31f7360c1..efe92e712 100644 --- a/encoding/gjson/gjson_z_example_load_test.go +++ b/encoding/gjson/gjson_z_example_load_test.go @@ -15,7 +15,7 @@ import ( func ExampleLoad() { jsonFilePath := gdebug.TestDataPath("json", "data1.json") - j, _ := gjson.Load(jsonFilePath, true) + j, _ := gjson.Load(jsonFilePath) fmt.Println(j.Get("name")) fmt.Println(j.Get("score")) @@ -30,7 +30,7 @@ func ExampleLoad() { func ExampleLoadJson() { jsonContent := `{"name":"john", "score":"100"}` - j, _ := gjson.LoadJson(jsonContent, true) + j, _ := gjson.LoadJson(jsonContent) fmt.Println(j.Get("name")) fmt.Println(j.Get("score")) @@ -45,7 +45,7 @@ func ExampleLoadXml() { john 100 ` - j, _ := gjson.LoadXml(xmlContent, true) + j, _ := gjson.LoadXml(xmlContent) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -60,7 +60,7 @@ func ExampleLoadIni() { name = john score = 100 ` - j, _ := gjson.LoadIni(iniContent, true) + j, _ := gjson.LoadIni(iniContent) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -75,7 +75,7 @@ func ExampleLoadYaml() { name: john score: 100` - j, _ := gjson.LoadYaml(yamlContent, true) + j, _ := gjson.LoadYaml(yamlContent) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -90,7 +90,7 @@ func ExampleLoadToml() { name = "john" score = 100` - j, _ := gjson.LoadToml(tomlContent, true) + j, _ := gjson.LoadToml(tomlContent) fmt.Println(j.Get("base.name")) fmt.Println(j.Get("base.score")) @@ -156,7 +156,7 @@ func ExampleLoadContentType() { 100 ` - j, _ := gjson.LoadContentType("json", jsonContent, true) + j, _ := gjson.LoadContentType("json", jsonContent) x, _ := gjson.LoadContentType("xml", xmlContent) j1, _ := gjson.LoadContentType("json", "") diff --git a/encoding/gjson/gjson_z_unit_feature_load_test.go b/encoding/gjson/gjson_z_unit_feature_load_test.go index d517e8de9..c4ae26bff 100644 --- a/encoding/gjson/gjson_z_unit_feature_load_test.go +++ b/encoding/gjson/gjson_z_unit_feature_load_test.go @@ -28,11 +28,17 @@ func Test_Load_JSON1(t *testing.T) { t.Assert(j.Get("a.1").Int(), 2) }) // JSON + gtest.C(t, func(t *gtest.T) { + errData := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`) + _, err := gjson.LoadContentType("json", errData, true) + t.AssertNE(err, nil) + }) + // JSON gtest.C(t, func(t *gtest.T) { path := "test.json" gfile.PutBytes(path, data) defer gfile.Remove(path) - j, err := gjson.Load(path) + j, err := gjson.Load(path, true) t.Assert(err, nil) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) @@ -68,6 +74,22 @@ func Test_Load_XML(t *testing.T) { t.Assert(j.Get("doc.a.1").Int(), 2) }) // XML + gtest.C(t, func(t *gtest.T) { + j, err := gjson.LoadXml(data, true) + t.Assert(err, nil) + t.Assert(j.Get("doc.n").String(), "123456789") + t.Assert(j.Get("doc.m").Map(), g.Map{"k": "v"}) + t.Assert(j.Get("doc.m.k").String(), "v") + t.Assert(j.Get("doc.a").Slice(), g.Slice{"1", "2", "3"}) + t.Assert(j.Get("doc.a.1").Int(), 2) + }) + // XML + gtest.C(t, func(t *gtest.T) { + errData := []byte(`123v123456789`) + _, err := gjson.LoadContentType("xml", errData, true) + t.AssertNE(err, nil) + }) + // XML gtest.C(t, func(t *gtest.T) { path := "test.xml" gfile.PutBytes(path, data) @@ -121,6 +143,16 @@ m: t.Assert(j.Get("a.1").Int(), 2) }) // YAML + gtest.C(t, func(t *gtest.T) { + j, err := gjson.LoadYaml(data, true) + t.Assert(err, nil) + t.Assert(j.Get("n").String(), "123456789") + t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) + t.Assert(j.Get("m.k").String(), "v") + t.Assert(j.Get("a").Slice(), g.Slice{1, 2, 3}) + t.Assert(j.Get("a.1").Int(), 2) + }) + // YAML gtest.C(t, func(t *gtest.T) { path := "test.yaml" gfile.PutBytes(path, data) @@ -142,6 +174,11 @@ func Test_Load_YAML2(t *testing.T) { t.Assert(err, nil) t.Assert(j.Get("i"), "123456789") }) + gtest.C(t, func(t *gtest.T) { + errData := []byte("i # 123456789") + _, err := gjson.LoadContentType("yaml", errData, true) + t.AssertNE(err, nil) + }) } func Test_Load_TOML1(t *testing.T) { @@ -163,6 +200,16 @@ n = 123456789 t.Assert(j.Get("a.1").Int(), 2) }) // TOML + gtest.C(t, func(t *gtest.T) { + j, err := gjson.LoadToml(data, true) + t.Assert(err, nil) + t.Assert(j.Get("n").String(), "123456789") + t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) + t.Assert(j.Get("m.k").String(), "v") + t.Assert(j.Get("a").Slice(), g.Slice{"1", "2", "3"}) + t.Assert(j.Get("a.1").Int(), 2) + }) + // TOML gtest.C(t, func(t *gtest.T) { path := "test.toml" gfile.PutBytes(path, data) @@ -184,6 +231,11 @@ func Test_Load_TOML2(t *testing.T) { t.Assert(err, nil) t.Assert(j.Get("i"), "123456789") }) + gtest.C(t, func(t *gtest.T) { + errData := []byte("i : 123456789") + _, err := gjson.LoadContentType("toml", errData, true) + t.AssertNE(err, nil) + }) } func Test_Load_Basic(t *testing.T) { @@ -245,6 +297,26 @@ enable=true gtest.Fatal(err) } }) + + gtest.C(t, func(t *gtest.T) { + j, err := gjson.LoadIni(data, true) + if err != nil { + gtest.Fatal(err) + } + + t.Assert(j.Get("addr.ip").String(), "127.0.0.1") + t.Assert(j.Get("addr.port").String(), "9001") + t.Assert(j.Get("addr.enable").String(), "true") + t.Assert(j.Get("DBINFO.type").String(), "mysql") + t.Assert(j.Get("DBINFO.user").String(), "root") + t.Assert(j.Get("DBINFO.password").String(), "password") + }) + + gtest.C(t, func(t *gtest.T) { + errData := []byte("i : 123456789") + _, err := gjson.LoadContentType("ini", errData, true) + t.AssertNE(err, nil) + }) } func Test_Load_YamlWithV3(t *testing.T) { diff --git a/encoding/gjson/gjson_z_unit_feature_struct_test.go b/encoding/gjson/gjson_z_unit_feature_struct_test.go index f6e2b7415..b7c514ff2 100644 --- a/encoding/gjson/gjson_z_unit_feature_struct_test.go +++ b/encoding/gjson/gjson_z_unit_feature_struct_test.go @@ -197,7 +197,7 @@ func Test_Struct1(t *testing.T) { }] }` data := new(UserCollectionAddReq) - j, err := gjson.LoadJson(jsonContent) + j, err := gjson.LoadJson(jsonContent, true) t.Assert(err, nil) err = j.Scan(data) t.Assert(err, nil) From 814450fd17f7f7cf7a3c2e7c6ceaf8f134ba8cd1 Mon Sep 17 00:00:00 2001 From: huangqian Date: Sun, 27 Feb 2022 13:22:26 +0800 Subject: [PATCH 019/136] gcmd example --- os/gcmd/gcmd_z_example_test.go | 111 +++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) diff --git a/os/gcmd/gcmd_z_example_test.go b/os/gcmd/gcmd_z_example_test.go index 491d5487f..6b6447067 100644 --- a/os/gcmd/gcmd_z_example_test.go +++ b/os/gcmd/gcmd_z_example_test.go @@ -7,7 +7,9 @@ package gcmd_test import ( + "context" "fmt" + "github.com/gogf/gf/v2/os/gctx" "os" "github.com/gogf/gf/v2/frame/g" @@ -93,3 +95,112 @@ func ExampleParse() { // true // false } + +func ExampleCommandFromCtx() { + var ( + command = gcmd.Command{ + Name: "start", + } + ) + + ctx := context.WithValue(gctx.New(), gcmd.CtxKeyCommand, &command) + unAddCtx := context.WithValue(gctx.New(), gcmd.CtxKeyCommand, &gcmd.Command{}) + nonKeyCtx := context.WithValue(gctx.New(), "Testkey", &gcmd.Command{}) + + fmt.Println(gcmd.CommandFromCtx(ctx).Name) + fmt.Println(gcmd.CommandFromCtx(unAddCtx).Name) + fmt.Println(gcmd.CommandFromCtx(nonKeyCtx) == nil) + + // Output: + // start + // + // true +} + +func ExampleCommand_AddCommand() { + commandRoot := &gcmd.Command{ + Name: "gf", + } + commandRoot.AddCommand(&gcmd.Command{ + Name: "start", + }, &gcmd.Command{}) + + commandRoot.Print() + + // Output: + //USAGE + // gf COMMAND [OPTION] + // + //COMMAND + // start +} + +func ExampleCommand_AddCommand_Repeat() { + commandRoot := &gcmd.Command{ + Name: "gf", + } + err := commandRoot.AddCommand(&gcmd.Command{ + Name: "start", + }, &gcmd.Command{ + Name: "stop", + }, &gcmd.Command{ + Name: "start", + }) + + fmt.Println(err) + + // Output: + // command "start" is already added to command "gf" +} + +func ExampleCommand_AddObject() { + var ( + command = gcmd.Command{ + Name: "start", + } + ) + + command.AddObject(&TestCmdObject{}) + + command.Print() + + // Output: + //USAGE + // start COMMAND [OPTION] + // + //COMMAND + // root root env command +} + +func ExampleCommand_AddObject_Error() { + var ( + command = gcmd.Command{ + Name: "start", + } + ) + + err := command.AddObject(&[]string{"Test"}) + + fmt.Println(err) + + // Output: + // input object should be type of struct, but got "*[]string" +} + +func ExampleCommand_Print() { + commandRoot := &gcmd.Command{ + Name: "gf", + } + commandRoot.AddCommand(&gcmd.Command{ + Name: "start", + }, &gcmd.Command{}) + + commandRoot.Print() + + // Output: + //USAGE + // gf COMMAND [OPTION] + // + //COMMAND + // start +} From 8acffd1186a34ad537c19f2ae190aa25e7f15611 Mon Sep 17 00:00:00 2001 From: huangqian Date: Sun, 27 Feb 2022 21:00:23 +0800 Subject: [PATCH 020/136] Improving gcmd Code Coverage --- os/gcmd/gcmd_parser.go | 2 +- os/gcmd/gcmd_z_example_test.go | 65 ++++++++++++++++++++++++++++++ os/gcmd/gcmd_z_unit_parser_test.go | 3 ++ 3 files changed, 69 insertions(+), 1 deletion(-) diff --git a/os/gcmd/gcmd_parser.go b/os/gcmd/gcmd_parser.go index 35aa4ae82..abbb6f251 100644 --- a/os/gcmd/gcmd_parser.go +++ b/os/gcmd/gcmd_parser.go @@ -200,7 +200,7 @@ func (p *Parser) GetOptAll() map[string]string { // GetArg returns the argument at `index` as gvar.Var. func (p *Parser) GetArg(index int, def ...string) *gvar.Var { - if index < len(p.parsedArgs) { + if index >= 0 && index < len(p.parsedArgs) { return gvar.New(p.parsedArgs[index]) } if len(def) > 0 { diff --git a/os/gcmd/gcmd_z_example_test.go b/os/gcmd/gcmd_z_example_test.go index 6b6447067..d5f661a41 100644 --- a/os/gcmd/gcmd_z_example_test.go +++ b/os/gcmd/gcmd_z_example_test.go @@ -55,6 +55,15 @@ func ExampleGetOpt() { // Opt["o"]: "gf.exe", Opt["y"]: "", Opt["d"]: "default value" } +func ExampleGetOpt_Def() { + gcmd.Init("gf", "build", "main.go", "-o=gf.exe", "-y") + + fmt.Println(gcmd.GetOpt("s", "Def").String()) + + // Output: + // Def +} + func ExampleGetOptAll() { gcmd.Init("gf", "build", "main.go", "-o=gf.exe", "-y") fmt.Printf(`%#v`, gcmd.GetOptAll()) @@ -87,6 +96,7 @@ func ExampleParse() { fmt.Println(p.GetOpt("y") != nil) fmt.Println(p.GetOpt("yes") != nil) fmt.Println(p.GetOpt("none") != nil) + fmt.Println(p.GetOpt("none", "Def")) // Output: // gf.exe @@ -94,6 +104,7 @@ func ExampleParse() { // true // true // false + // Def } func ExampleCommandFromCtx() { @@ -204,3 +215,57 @@ func ExampleCommand_Print() { //COMMAND // start } + +func ExampleScan() { + fmt.Println(gcmd.Scan("gf scan")) + + // Output: + // gf scan +} + +func ExampleScanf() { + fmt.Println(gcmd.Scanf("gf %s", "scanf")) + + // Output: + // gf scanf +} + +func ExampleParserFromCtx() { + parser, _ := gcmd.Parse(nil) + + ctx := context.WithValue(gctx.New(), gcmd.CtxKeyParser, parser) + nilCtx := context.WithValue(gctx.New(), "NilCtxKeyParser", parser) + + fmt.Println(gcmd.ParserFromCtx(ctx).GetArgAll()) + fmt.Println(gcmd.ParserFromCtx(nilCtx) == nil) + + // Output: + // [gf build main.go] + // true +} + +func ExampleParseArgs() { + p, _ := gcmd.ParseArgs([]string{ + "gf", "--force", "remove", "-fq", "-p=www", "path", "-n", "root", + }, nil) + + fmt.Println(p.GetArgAll()) + fmt.Println(p.GetOptAll()) + + // Output: + // [gf path] + // map[force:remove fq: n:root p:www] +} + +func ExampleParser_GetArg() { + p, _ := gcmd.ParseArgs([]string{ + "gf", "--force", "remove", "-fq", "-p=www", "path", "-n", "root", + }, nil) + + fmt.Println(p.GetArg(-1, "Def").String()) + fmt.Println(p.GetArg(-1) == nil) + + // Output: + // Def + // true +} diff --git a/os/gcmd/gcmd_z_unit_parser_test.go b/os/gcmd/gcmd_z_unit_parser_test.go index 7fd45a02a..2b7699f68 100644 --- a/os/gcmd/gcmd_z_unit_parser_test.go +++ b/os/gcmd/gcmd_z_unit_parser_test.go @@ -48,6 +48,9 @@ func Test_Parse(t *testing.T) { t.Assert(p.GetOpt("q") != nil, true) t.Assert(p.GetOpt("quiet") != nil, true) t.Assert(p.GetOpt("none") != nil, false) + + _, err = p.MarshalJSON() + t.AssertNil(err) }) } From 456697ea99ff673157ad0df1308eef08163b5207 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 28 Feb 2022 17:48:52 +0800 Subject: [PATCH 021/136] improve cli command install --- cmd/gf/internal/cmd/cmd_build.go | 12 ++++++- cmd/gf/internal/cmd/cmd_docker.go | 1 + cmd/gf/internal/service/install.go | 54 +++++++++++++++++++----------- util/gconv/gconv_slice_any.go | 9 ++--- 4 files changed, 50 insertions(+), 26 deletions(-) diff --git a/cmd/gf/internal/cmd/cmd_build.go b/cmd/gf/internal/cmd/cmd_build.go index 9a42ca5f1..871b49673 100644 --- a/cmd/gf/internal/cmd/cmd_build.go +++ b/cmd/gf/internal/cmd/cmd_build.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "fmt" + "os" "regexp" "runtime" "strings" @@ -119,6 +120,7 @@ type cBuildInput struct { Mod string `short:"m" name:"mod" brief:"like \"-mod\" option of \"go build\", use \"-m none\" to disable go module"` Cgo bool `short:"c" name:"cgo" brief:"enable or disable cgo feature, it's disabled in default" orphan:"true"` VarMap g.Map `short:"r" name:"varMap" brief:"custom built embedded variable into binary"` + Exit bool `name:"exit" brief:"exit building when any error occurs, default is false" orphan:"true"` Pack string `name:"pack" brief:"pack specified folder into temporary go file before building and removes it after built"` } type cBuildOutput struct{} @@ -254,7 +256,14 @@ func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, e cmdShow, _ := gregex.ReplaceString(`\s+(-ldflags ".+?")\s+`, " ", cmd) mlog.Print(cmdShow) if result, err := gproc.ShellExec(cmd); err != nil { - mlog.Printf("failed to build, os:%s, arch:%s, error:\n%s\n", system, arch, gstr.Trim(result)) + mlog.Printf( + "failed to build, os:%s, arch:%s, error:\n%s\n\n%s\n", + system, arch, gstr.Trim(result), + `you may use command option "--debug" to enable debug info and check the details`, + ) + if in.Exit { + os.Exit(1) + } } else { mlog.Debug(gstr.Trim(result)) } @@ -264,6 +273,7 @@ func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, e } } } + buildDone: mlog.Print("done!") return diff --git a/cmd/gf/internal/cmd/cmd_docker.go b/cmd/gf/internal/cmd/cmd_docker.go index e4368ca4d..dd96854ab 100644 --- a/cmd/gf/internal/cmd/cmd_docker.go +++ b/cmd/gf/internal/cmd/cmd_docker.go @@ -81,6 +81,7 @@ func (c cDocker) Index(ctx context.Context, in cDockerInput) (out *cDockerOutput } // Binary build. + in.Build += " --exit" if in.Main != "" { if err = gproc.ShellRun(fmt.Sprintf(`gf build %s %s`, in.Main, in.Build)); err != nil { return diff --git a/cmd/gf/internal/service/install.go b/cmd/gf/internal/service/install.go index 3448b6ce5..c5d3fec86 100644 --- a/cmd/gf/internal/service/install.go +++ b/cmd/gf/internal/service/install.go @@ -32,7 +32,7 @@ type serviceInstallAvailablePath struct { func (s serviceInstall) Run(ctx context.Context) (err error) { // Ask where to install. - paths := s.getInstallPathsData() + paths := s.getAvailablePaths() if len(paths) <= 0 { mlog.Printf("no path detected, you can manually install gf by copying the binary to path folder.") return @@ -43,16 +43,21 @@ func (s serviceInstall) Run(ctx context.Context) (err error) { // Print all paths status and determine the default selectedID value. var ( selectedID = -1 + newPaths []serviceInstallAvailablePath pathSet = gset.NewStrSet() // Used for repeated items filtering. ) - for id, aPath := range paths { - if !pathSet.AddIfNotExist(aPath.dirPath) { + for _, path := range paths { + if !pathSet.AddIfNotExist(path.dirPath) { continue } - mlog.Printf(" %2d | %8t | %9t | %s", id, aPath.writable, aPath.installed, aPath.dirPath) + newPaths = append(newPaths, path) + } + paths = newPaths + for id, path := range paths { + mlog.Printf(" %2d | %8t | %9t | %s", id, path.writable, path.installed, path.dirPath) if selectedID == -1 { // Use the previously installed path as the most priority choice. - if aPath.installed { + if path.installed { selectedID = id } } @@ -61,6 +66,7 @@ func (s serviceInstall) Run(ctx context.Context) (err error) { if selectedID == -1 { // Order by choosing priority. commonPaths := garray.NewStrArrayFrom(g.SliceStr{ + s.getGoPathBin(), `/usr/local/bin`, `/usr/bin`, `/usr/sbin`, @@ -121,10 +127,10 @@ func (s serviceInstall) Run(ctx context.Context) (err error) { } // Uninstall the old binary. - for _, aPath := range paths { + for _, path := range paths { // Do not delete myself. - if aPath.filePath != "" && aPath.filePath != dstPath.filePath && gfile.SelfPath() != aPath.filePath { - _ = gfile.Remove(aPath.filePath) + if path.filePath != "" && path.filePath != dstPath.filePath && gfile.SelfPath() != path.filePath { + _ = gfile.Remove(path.filePath) } } return @@ -132,7 +138,7 @@ func (s serviceInstall) Run(ctx context.Context) (err error) { // IsInstalled checks and returns whether the binary is installed. func (s serviceInstall) IsInstalled() bool { - paths := s.getInstallPathsData() + paths := s.getAvailablePaths() for _, aPath := range paths { if aPath.installed { return true @@ -141,11 +147,26 @@ func (s serviceInstall) IsInstalled() bool { return false } -// GetInstallPathsData returns the installation paths data for the binary. -func (s serviceInstall) getInstallPathsData() []serviceInstallAvailablePath { - var folderPaths []serviceInstallAvailablePath - // Pre generate binaryFileName. - binaryFileName := "gf" + gfile.Ext(gfile.SelfPath()) +// getGoPathBinFilePath retrieves ad returns the GOPATH/bin path for binary. +func (s serviceInstall) getGoPathBin() string { + if goPath := genv.Get(`GOPATH`).String(); goPath != "" { + return gfile.Join(goPath, "bin") + } + return "" +} + +// getAvailablePaths returns the installation paths data for the binary. +func (s serviceInstall) getAvailablePaths() []serviceInstallAvailablePath { + var ( + folderPaths []serviceInstallAvailablePath + binaryFileName = "gf" + gfile.Ext(gfile.SelfPath()) + ) + // $GOPATH/bin + if goPathBin := s.getGoPathBin(); goPathBin != "" { + folderPaths = s.checkAndAppendToAvailablePath( + folderPaths, goPathBin, binaryFileName, + ) + } switch runtime.GOOS { case "darwin": darwinInstallationCheckPaths := []string{"/usr/local/bin"} @@ -157,11 +178,6 @@ func (s serviceInstall) getInstallPathsData() []serviceInstallAvailablePath { fallthrough default: - // $GOPATH/bin - gopath := gfile.Join(runtime.GOROOT(), "bin") - folderPaths = s.checkAndAppendToAvailablePath( - folderPaths, gopath, binaryFileName, - ) // Search and find the writable directory path. envPath := genv.Get("PATH", genv.Get("Path").String()).String() if gstr.Contains(envPath, ";") { diff --git a/util/gconv/gconv_slice_any.go b/util/gconv/gconv_slice_any.go index d4f73f610..092d19694 100644 --- a/util/gconv/gconv_slice_any.go +++ b/util/gconv/gconv_slice_any.go @@ -22,13 +22,10 @@ func Interfaces(any interface{}) []interface{} { if any == nil { return nil } - if r, ok := any.([]interface{}); ok { - return r - } - var ( - array []interface{} = nil - ) + var array []interface{} switch value := any.(type) { + case []interface{}: + array = value case []string: array = make([]interface{}, len(value)) for k, v := range value { From 0516159ae38e9f9396ea2c16521c9e69dfa5b21f Mon Sep 17 00:00:00 2001 From: huangqian Date: Mon, 28 Feb 2022 21:11:53 +0800 Subject: [PATCH 022/136] Improving gcmd Code Coverage --- os/gcmd/gcmd_z_unit_feature_object1_test.go | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/os/gcmd/gcmd_z_unit_feature_object1_test.go b/os/gcmd/gcmd_z_unit_feature_object1_test.go index dcde693de..4027b7fb1 100644 --- a/os/gcmd/gcmd_z_unit_feature_object1_test.go +++ b/os/gcmd/gcmd_z_unit_feature_object1_test.go @@ -63,6 +63,21 @@ func Test_Command_NewFromObject_Help(t *testing.T) { }) } +func Test_Command_NewFromObject_Run(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + var ( + ctx = gctx.New() + cmd, err = gcmd.NewFromObject(&TestCmdObject{}) + ) + t.AssertNil(err) + t.Assert(cmd.Name, "root") + + os.Args = []string{"root", "test", "-n=john"} + + cmd.Run(ctx) + }) +} + func Test_Command_NewFromObject_RunWithValue(t *testing.T) { gtest.C(t, func(t *gtest.T) { var ( From 3edbcb7bf968c985d434fe36d928bb06a2750821 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 28 Feb 2022 21:57:59 +0800 Subject: [PATCH 023/136] gf cli update --- cmd/gf/internal/packed/template-mono.go | 2 +- cmd/gf/internal/packed/template-single.go | 2 +- cmd/gf/internal/utility/mlog/mlog.go | 13 ++++++------- 3 files changed, 8 insertions(+), 9 deletions(-) diff --git a/cmd/gf/internal/packed/template-mono.go b/cmd/gf/internal/packed/template-mono.go index 0f37e7ba9..480a35936 100644 --- a/cmd/gf/internal/packed/template-mono.go +++ b/cmd/gf/internal/packed/template-mono.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("H4sIAAAAAAAC/+y9BVSVS9s+/pAiIKASBikhvWmkW+kuKemGDWwaCSmlU0AQUUQUkRKREhCkW0C6ke5G8r/O+77nHLZHcbPB979+3/ex1jksXa77muueeeaZ575m5pKXQkLGBdAANIATrKUMHPohBM4C9kZWNpZ69kYMVmBrMIjRxMxez97ezkzfwd4IoqKMAiD0dhDqtynW1jVKgZroGT83STRKgWSk5fIcNs8gA8DBgbzUGbR2eWZuQgAA8AEA+DncpR/CmZlYg+2M/oISbcqx+siEifJ5P2zUW+vaVWevjzFoATkMF66NvyEhpWnTsQ1rfuG0Ts7zitPqU6r8XZ7al+4SEuEyVlsWGuO68uKpofiYrs/V8arpnvca4rr1C1MNqDKyydz5TMO9ax6sdOb5bmQ3R2rYHkQuYeXgWbR4NWTKK2PtYXB0zbfrf9J5Uccg7AUAQNqRdAj+QUdRTEhURoxRRvQvNoqqNi1OdJKNMipoEk0MtRL0Eio2DSDFpaaWBmxJhtpJxL9SaDlfGk0FAADpIUzgH5jn/4GpZ2PzF9ofcQ7/65/HIf5RHJCejRnDn3/7y6D/TMj1XwYFyehZGBmbWf4dHX1lEzvAaRlTUV5ePltF/jN1s3hTnQI1tdznryuQNYdzWDb2jihSNC9SUiljJqKpbQsLULe2blX7pAiNBqA8KqJMK0ThCqBMk9Ri3G8ezBS6QVHIshoJkVRSxFtbW1tfW2O9EJW7HrUKgayurtnlIiD8me5B0g4NewAAAo9ME8WvGenZmDkyw5EsBhhDg0yNLC3BjCbgvzAsQ3NkfZgxfSe3aejlstm8meVa/fxCMiZqbK/pX7jw0tzP2amDhYz5ib3TUJeLmwneVx1ZbKDK9WqoUzY5w5OuWQ8L/Hdm6PEV08wp5VRCZxcQdttQsBUt3GLkHvN3Tmyh8AwIBLAS87iF4q7kCU29YW0b4YxztgZHKD+2YWQljhUHWenRGnAPcqjRcFds3mnbvW9YRRHZ0CPimO5rZzyrck2GZFwEDBL4K9VWt6yG3gAAMHtkqmEYPGbW9kZ21nqWcIx3OtijgwysDOHoT5bjIfzx3+FOtQ8vN+9nwvFvaVPC5O4pz3l6S4Tx7LvClGgGd680PlXRFxGX6voEe5xAMfkU9xfqGgWSPN2lq78RcHtzMWrsxEUpT71jgYxKgr+YZgSvrjvscDXTaMT2mw+YtyTN0V6q44Zc1H3dWdIZDyZPU+esGfcUfBGHpFoUFhBV9ZjB2PMAlPeE7qxBdvGrFBzx4IU8/udz+6Cpy8S6IJIkxeDaBpKMDrVgNoS4B0+anj7cVmj9vEbmjCs3i5yqHI1ezIcbySrR5zHo/ER3wHlhYhu1izxErsbJK1hRfDizZCfjHJ89BSJFZMp9bWG8OOKPIUOa4K58091rZg2JOcY3tgf4P2nzDDtLalKa1eaJ5O1tjcZStoJxZ7BW+Jxv6iDWBUjKar06WOp6PvnCItdVYGhLmizlWdW5Uq0m2askkcIOF1E3hOgcLr8rmtI5OPfnmJt2ZyaXQgAAIcSjRgXjcfoMbA2xh8AxMG4cG+Q/vw4PD1px6WZZaTkV8eYWOkaaib9fGx8JMBvxAADAPnL4sxyvDfZ2YEtLIzs4yPLABfTDOc6alQzHd7bvZXfSTPNb7L1ppduBisW2MrXEXCjqH+Zuh9KXuVX2mCXjmg4nnGet+iZHgMZnghcagawr6yeWc7+ZTZqAHUg8m+tBD34+aYh0v86/7knSHAVjxLmJMC9F2s808xdM3mfiztZ/2Hk2b7sP1gVu8JhZZeGSj7Fur9uVsEuVofMBqg+rZtdRmRh6DBZtIU6oWi82XctrRm09uxjQE21yHUMsZgRfIrg92w7qZIgU56FH0nmGMXZPFkPF/bysW8m7xfvLgnk2mWzERqqBhZybtrditvZbMFvPTl+7bL1E9GcPorM8958EAEAL4ageZDhGYq3AhkaWcHQex3Ex/rV+szAy+nsF8tek/0c8lF9Oy2zHRjSytjezd4GDHB+cUCfmeJxJxkbPwMLI8DdPMv8G+c+vH00ywOc0Gq0/1r//prmKav7l4i+nGNAxWgAxsnM0MzD6zTz/g3LiDoQH8wRLFd4TwIEM9cBwZFXshJAnTjHPiRoAD2XRkyEek/E/8al+jW+lZ2Z9+PEMDhVCr2DCEetKVPJ9EynGOsxnP4JiKN1+aU5aOPE16aA2bUGbX1/LZEkX9ROa65+UkZ/apOdeOTNQ3q219o5Q5E1w4cR5dtsEcaUWFVpFC/GMtSS8INN4PyqtCLNsYIDgWpjzgG6JbqhrvgDWAfc1bHzejwXid/N5wMStYsQVMYG+e9esHXy1i7gWR85m/TU5CAa7xkUAADB90sW9lZ61mbERxB6OJ4YR9uh/LDqMzUzgGDDcxwb5zy9GFz2rv+cBtmAFdERmTNEDSCDZmVYPSdkRPMRzs5LdMSmaWSA8p1Jj50apIDMyZNMMvUfeeDG3aPzOmg5gze8o1Uh9dJrfmU+cV6cWKLLCJ9iWo1p5Xx9ZJANBUx/wjFXo40ImlyW/to36Z8/cScMKNQYAwPPUcmdoZGMJdoGjg24cGwRk4QCxB1uZuRrBAcd3AjiQvh4EnheTzEkx//O3VkbW9tAjxj6sRLaGCbNyk7eqRNCvyFhE33Cq0loRg/4xdhVqR/4thECNjgMZhebNdiJ2l1FrRSnkPGMnEohz1NubvDbtRUaMxCw8GV9xkeSpIcib5lEQa8lmBHlX47wRA919EvUxtsZmGcoIsUYEJlVZnR05+qiXXTVIk5HIcy1DHc96w58AnDgfdUypv4xS+O2QcbgviopS0XiWeRm6FsZ5vo11+vLidQrDqI6AWS5OKeKfQ89GNiH9jynCBOGolMmfOGV//lHP3gxsDZ01+vqccxVMOCit+6lLiMyS9z8g8pXY8k81LGt/hVzzm6YR/5YSy8n/OTGVpmPgPrvH+aDphCT1RWKzfAMPva+3aR0kRmwzeE1piazdQEsUSurZGY4cUw9MrNOlyz9j4+/SXCv7awasQqur/uM5Ax85PiRPTPY/byFomlohzOiIQphiO4+vEai3yra53kOp4m/0MLQxucCi1wLiCdHd3Fr8pJQFqnzV6RdG524+5Evy4Dm+vMhMappwo/ZV3/McMaKr2hfZCMftrSPGfI2Sl+aFGxuJY1QtCTwGuwpTqq8W7ssi8Uhq1HbM7A89Bf9FO9H0cbgjAADJRz6KQiehDXY0srPUc4HAMQVInAYuyNDI0cgSbAPHdKB+mvj/eZFY6dlAd75lmIzUJ0Ec/8VveCJ+yferUz+rogZ6E8/KfJDLjcq23/g0IPFsOCy2Wvmc8+NNHyfiwI1Epffl5ITpo7olQs5YpXkDdFUVOZFklPQAL9fNYdwV4R4xsnExVgqiqtHIbdX6i1xCW/QAkDnsF70R7WK/I2ruAzrTFUyMReDlmzlmXwj4htGjMZFH9ITFf/HVOc+2zhvorzkjdsCWIfA4aCFaAFkJLfDL69LiO2DiCbneylnzPJrY8bdvsjNjZxP6Mt2jWy2dnpE9uiX5aOjN2LzLmFPPUuli9ch5MOeHXZJ+XGNBhMdPpQX/nlVAe/wuswAAhB45q+ieaub/npQZ/nj+jOy+e/yamF9/EsREbvWQYyZgShp63Xy5DcMN7VqMqrMfWT42lmXgqwtg3ZvtC7z+6zimE1s8B33t+hf749w8uZ7H59q3K5oJvlL6+DzsxVShRU7IV1eji5kkca4Dvc87vGviEOmTGNG0GErR42bHnIQ5nvS7lSL9mQvXsnhaBwAAso4chVqnmoujZttGGXNfQZxby+6JySDdgOJWNbTbKG9BfWWprftP0wltZAUwx/Y3n7DtiXBmUPrvsWXdThpWbnh9dfFOtUZNDdsno2TthgufNjMq8/CTsdJN5LLFRXSJH9XcxmTzbaGQGpNaEeqobBeY6yq+wSEjMHV18Iu3Ywfd8y2GIEP1KN9L+G/siGVF19D/TM7ui9rdQAAA0k9v5QM2sICrHsZ1bBCQ6L9+QYkkdhgrmyq1dXLSNJ1yjTS1jVJ5LJ25w6OKqYzDiqqkAO+etwih+11CEd69vVfWPLHpd+KECzzD84NMcPybtgNQULRCGRnRxdKqvr0Qq0ubQld+yr1e/nptTUoRgrEGYVmVpBu9CFFqlF6DXGRdxXktyJv5VF7A72tw/y4uyjw6G83rnVDdblpqauT7N1D95AeM1cMreGvH5zDQSbM5/1ZUkq3DJp4BAHAb8YQf8N8n5N+/GCGmh1S1Drn6xnY5Sfrm4VFFVbS6WnrVfwtHtfSq4hniMowMEjIK4pIyDSBJFfE6uWZZBkVx2qZGic9jiEiCf73CInIVl0UAABA86beLnREE7GBnAM9alR726CAz5hvWcIxB9mNC/DcqXn8B2jjoW5oZwJE41mODgEztreApi/LCh3TiNLIfH9fG0sHEDJ4xwg8v1olZch4f+QSPGw/8aCADCOT3FJqOQjxxfvlOgG9mpWcCz8fwzZNinpg19wlaYA5PN4ucCPDEfJmOAX+CHR5ccMCcmNuP96qYg/VPf6/K4aCnulfl9jcJ+Peq3Hk3jvfrvSowMDr1DRQ/jH6qGyh+ivD9BgrfiM9BHUw41UlRZfqNSm7RyHe1Cs4siuIqV1aZgBJSe5ybGlkkWpB6DrQjY1ZvaL0Ib5vmXN0prasrcrvKW8Amebk9oEDwup+db5UAPqVf8psUXNpKOy2sXgWWexWGFYbEOgkBVitUr4IQ66kK2PZvffQ9UH0c9ziyJBo7Jr1cjuOalghRBpiGMmgMRFNpkrCLJUh5VeGc4gNwD2qZm2rByNRLolda9ASvhvWxl3yw5heLUQawUlG0J+vJLTVb82fdvKLG5y5nXtmU2pl6tto4/CjA7RWVaCsJjX3JvtfFL1xI/SryLwTHBtdVNtxfaTOgXJzhHCsI/ILHy2deMGXsw/d5cPvTBZ1RZ6HgS6rDhYm25t1qXV62g8bZIAyDDE5tvuB7WfyVWrwi/IxGKUlot4LG5m7nR6/Lvp51x1zs2vZod2iChCJQz7pjmk7GWh8UJWTsFWoaDBtTOWFD8hRzBbm2BULtEjLz8zhluq50iSs+WCWtur2x4vTXUhpXIETUFQEAZuHYb/GTLj7d/RZHgZz+fguGY7ThdNX6IzB+k1p/FOIpq/W/hvpN3y4/Bj5ltf4okP+OWv/jFpy2Wn8kym9S64/GPHW1Hja4U1XrYYf8TWo9rA04PbUeZsTfpNZD4f9TrWcOrWDCEZttpKFXczwf9m6zm2ED0XT0RnX4oxxvJPEHxc9JFYSEdtbXB9Nxw6Kj9GgR5Qtm2oJ9rE0sGa3KsMhoDTp59aS0TMzTTPDEXuNhc69l4QW9e4fWVEDWbopQxCn6ZGnXx7WCsO+Lx427sw94NZaAdtrlnoUPhUIELphlyhS7WaMct7akCCb5+kfO/8k3oWNULQpOvf47vqes1/8w+mnr9UeB/FCvr6+Tk5NjeDuqKF8rwSDVpJCtKC/ZWKcwqihPzShRB2LIUaSmoZVB+Wt9kGdsV0j/rxFzWhk4ZdX9KJDfoLrDBne6qvsxMP9PdT9+yv6fV92PQ/Z/kOoOI+1TV92PiXvqqjuc+P+nup9YdYc38/8TVXd4c/G/QnX/SXJOV3U/CuR/pep+ZEL+f1bdf1z0hzganH7R/3DQUy36VxnVwV/0z2zNnIH3gCoUI3gPqNLDGBpkZGAKdXZLqzlHtpIJs3q50AW94aL41LVLuUykqKgxs5WqUUXWyGZ2AZo0wh94AtVlOTWHWg6k94N879ndIA45y/wy2cYENfrp7L7LCo2GxFv123PLhrHCERlPCzlvaho7r1tcSUv8hqjSsIDn0Uj60kkVMY5leqb17Z2ojA6c6BTuOfJLhYTlrMKG2u1z8urnZ4jJH04skc/Lp/F9vLrGJWvsLJGwkrqn0I2c+klvpIEYvQUt1+mGok98EQGHS3Xd7qBqZ3q9ZiaGSfPQud2DF0ief/VFB62BWzMAAGQIx/9ohkrYqQswP4x+qgLMTxH+eYK1xbyfCaca6gTrHkSCRnMbUHJ5g5d3U58CjGQ0VKI+GEkYH/UI7LG/ZsBSdGfqrNbjPCzm62mtZkZao5KgL6YZwdjrH/YItQM7r5epl3U3nClGu/l28AMGk8psS97EZoTyGyfbfRJ5mgk8uoGayjr95vda/XtlHaiZFMHpA2KUGXQBn0s6CaIHDi4jfUKaGx9TCjzvsv/84XZgBBVwkTn78jtFAXTX+EHksAumjz5GByrq5d8XtiMz65O7Wnw2JkR7cgajP5SNn2gIgUWS7F7xxkI+x1prBFq4eCSx41kVXVdAwANcoj2UvJybwuBUHT8ytbmD6TTvNUZj9TCFLB/ry8YYJG7yocdzeafwrHKCry6UXAp1ARjr4H1XTF4nK9WsyasCRZArGr3dszJz75ZHqJU59YazzV9k+qiqDcyW/TXowM0D8tIIACAIh6Tyk047XUnlKJBfSyqjiO3oV7Qeh6KgPKFBf49+tspI7K/J8qxW/KGK9hiP5032f43P4x9x/Wkb4T/iyg0X0D9mScPQFnMfQZzqlmYlTOJA1LE2i2cv2whMn+jySAcrO3GMUZ/vcQJZtElB1PlLBXYdk1+SDDFHIitdRlX18ghO9sfDNQr9ZkwpqOBYoj2xGGNon2hvYsJbXX6V5NbZ0bvB1hpTW7HcJDvjeb5XdJfj9ZLsz9+9VV/0Qqv7yrcFW5bEuvfINk+Q9MScu4OuyHlk1Fpv3XixV2DhU6/GO1f2zsVlZZbgjsWb6Jcv75qHq6xezLD1Ee4xPre14pk/v6ULvjzEL23OtIZEsfXXgWuATrK24Y/xCMcp1h/n7nR1sSMwfpMudhTiKetiv4b6TbrYj4FPWRc7CuS/o4v9uAWnrYsdifKbdLGjMU9dF4MN7lR1Mdghf5MuBmsDTk8XgxnxN+liUPgw6mJxN6qvsb6/cJ2UbCHUWxQFZb6ryy3rQhKNGHk0HqkUA4QVq8gnhya/3RVTC1lJgvw9tUMyvhuNRrh5ldHYfp5+J77Ji7NOhoT0gpv+4uTWAur40v2ZG59GNM806JYjBaev5A64QHxCjdDKotl3s2Ycb20FQetiXGpvyeDVxb7je8q62A+jn7YudhTIT8+xVjDhiB5AAvWwn26ZbOLq6JGJZNDLdMvMrlMmr7J/MtBhkfXH/2h+zpjWWHQx3ygC8V3zwPZG9rJy7ZdtRxejvuv1+Rl0Y2EeSpLLHA3R3HLcuPoLQw2v5i8Fnj/z9+1B78ZKs4wAAHA7tdSdsqB2FMhvENRggztdQe0YmP8nqB0/Zf/PC2rHIfs/SFCDkfapC2rHxD11QQ1O/P8T1E4sqMGb+f+Jghq8ufhfIaj9JDmnK6gdBfK/UlA7MiH/PwtqdMdoMcQWnsIb2/EQQA6QP9JxCCq4NUfykyBhzXKJ3PJQvJePtzcpUeZ0WvnXa8ss9jNEdWlCrmdjg5oZ25rE3rRWSQzM4TBMrVJ8zg+/kt1G0w7evns/adxAlFm+w4kpm/di4L3PCLq2laQxvd29bGSxt+9SiSFXPhdErEHAlQcbXmyoYaTCpW/ZG7B231SUwd94WpxjmcLb0CZqhhqr5TepdbmPZ4L2bWpp4MsVx5xItYDA3rqV9VSPD9YpwZ8w6mqSE98QD85MupCLUBbgk2deFtXCIApDwVziR3/soClrPD55i9394Al+SFP7qxcZxmIOAgcmYe59Yvs4oUs4wePzxjXI0liW3m7vo+ueHqi9xYrw9DYDdb0sdktM+qtfuZlXyDAQAKD4pKrTqR9P/mH00z2e/HOIExctcP8BaAJmtAL/XbA0rG8650eKCQy7vdRFqG9puCqeo3zB/KH8hBOwmDSll0iY79IbKkaZbXcu6utCHwXIlQZIl4rbB3yILcZmC/0fDtRfYt5W8Fj66yomVoQaJpl/LaeO3S6Ig9Vf7XpXJJGfLN63ySOQlDzByHleiOBxXjOAcP48HgquyZo7NqLHdm7/7Za9qcwi1k1N8DgFJMzjgI4xi+MB9fRY+d7Sa2/1c1Y9SfcZZR+U0q4ILAz7bHt5Vi4dPCTye3hhmfaJ8BlN7ceXaYqfYHA44rNSZUZdCHhVL005EHIwdLAqde28ConYuEB5hX3eQ3e64ZsSKXYDxFTlevmsJRrgFQuz+FeOF+WuGDu1DX3Uaf0iexWnHZdHW7r/M4nTGoJAa5RZUmbOlSvJrJjRUebn2UI/bwu+NGJ8GjKMX5w+cZllvvD9GsNEUGHMXZRk2RlpRwn10lGfhO4aiojIdAfPgsSpWWuGWzoJ6PcXiBKLZW9TGYniKm1ff7T/NKm2/uOSNapi8qzvlFV/jcuCnJG9YccjHnpHjOwr5WMfHK7JbmOtVHU7J2nFY6SMik0wsHk2ncXUU3vJ9PD9l4A3qKmgsyUa/Uhr1m8W+5FAgQGvNBwdmPZt75MsIX3wyn8TYrXovSHRL+ancr4qsfEb8/WiueyXkQNUfE71Fc85KfbZt1hLF2hiLyDZJ6wwio9sMMXbJpFsKbVHBHH0dXNQKO3oxxHOuvtsgeOu5EFiKeVsrkZ7LBWoiWxi3llCiEEjBZiuIaSoR2rbkWEAa2R2U0tpj0heBYlnBHT2YiAVmqVoE3uxcS04poeiDI4PY+dz84gE7Dmx3QmdPZfqUMQ90Bze9cZnbLU5caKP3Z3+6RUVOjtcmdjCyQERl02DqTUJaWcVnbwkfgqBjxfvO53p83ntzouf+/qc2xtN8f4kRjcnNebiq+KORDq43/ypau6M6AQ3Ot5960AStjpCpeHmgj87zGRF4yjC3DTDffPdWwwttxJ+3x6ePLp0/rOTB7vLhkokcxjcRGMLQoWEXBdqxtIo4/neTV4jtAnr0S7EfydZtqmi8XJ2hsd0AWWP+uqjyBQUMwz+RcJECeH8KBkgtfSRxznXBMVkV/nhb6kHV2QO0HZGJ6Ynqttk9hSJsro80ApdwjNnhk3wZ6ioEart764r3qrPjwNNXKGoaxurd7Tet568vdOY23//Q04PzkTl0zbUputMZA8V2Ydak8onrxMtjw3x7I+FCpDuPuX3LJQxMhmZr6WfAeSbe6kNbD/Vjk4Pt652Dllm7BlGWAQyJy8K3cG8yclmba12JwtlmbYu7Gb6B+k3m7nucvKyRC+fcFlpxogELdMVW6y8GKLafEoZWGix8pIzjuT8hwvBcSwdJWYE94VZ+RKVI7dzUmc5AiZ2G3Wy0qL9KoxviA+llMbRo4e5jhEyMqhm+tktgL/YgMZS0e1ky54PmFfn3HvjzJq1Pxo6OM2S3BCl38Mn41Jnh0aqSyYS5aUZiYuFMFmcOVsy4w+p1A+0YpngBU8YlIEqZW6/c9KHmCa8EcDAuIeR55e91/AsOfxBhUBClVLWeu11m0S8YgdCIl9NrvwHvTiO9bezF5otC4y4cgSwJmuuXX+bs+px7i5zR1puqUkwb8GaN0sntv+HrCu5hDmOVZ/FMqxXcQPWHQZu9RJYL0SfV8hXuVMosrXG67rKGzWL0lAYtBtvOsJ37YMmQrMdXmpgqzpdLjhs7cMXdDGvO893QLoz7TP5/cuIJiyfdMcwcC+BBqYu3roZQd6kIFGsepG76usLLHEz1tHFNoGPNSYot9CuRerj5BmqJ3nzB/AhLwVtpKzEygCd9vKosbO9116MmAf4y1cGzWcrWoVf//h5gg68NNThkXjHsXCtVTEwzOU9njPXU2UrysH8em+S4lJ2C4uDcGdB4tn3O1SJ20lREeGiFF+pXaf1UcMf3L25MAt2ZJbATtdJhexyqzfO5kwWBTkookg92nzs1P/m/aT79MKlDQvvg8QNi89Zd1czQwm6HFOal6uCdcIQ5nPmGHvSO+8pVbqRkzvgZA13DauBVfTZO654frxfnF2ypKOKcDvm4VTl47h6Jct8njB6ifyXCt/w4jxynQeINjoDBCCofTRBifr4BORrc5aQp4TjLPz6LVyrXzZwaHuyypNYF6dtlNV2HF7dOqMkVdF0V+vVe7cspa6szh3rkVdvnJvakS+V2TPuTfikv9hJySPJq3p/vk7yprFXZDw6dvyjELUD2u267DObSmrddz6qRJ9pUZzEW8/9UNICqIN5mV3fGUclMJI9f26tFUkWnl5j431JKWLRYjWOuW7BAvEABcPzzAZfxUI3525ieh21Eu9oaclkUPgzBt+7nMVFX6iZzQxxPnuwuzMU3MleRNoue2DEn5A481oYIsBSn8zQmUDMlK/fubODLnfXcXlsvd87obDM5U5MWtnYHp3xe4knPJWXCrTHjYQOTPz5HmFUtBJ+2qB2T1ybcZyx73yCFImf28C36jSorXrVihmBdbfXdv/JN/1M9wquECGuzXsek3jkwsshxRrM421rwixnaybbcfx7qfb1rTWNWh7RLgTd7Vm3UgS5XZ+JUVh/zuMpa0nKNrpeAAHNRdRiBeTMAIUL702CeMzEye2FeaK9+dM0UPZbhrOiWl10e1/jmCJqdPlkcsUSxWuj6u+/qwhQYfZ1Hr3xZLlsDtt2fvzL8MWSqLtYdMMM/kQEHLc4Vc2H4lIsywqby7lSFpftuTCIPt/xjhGu2WaaHnczx5Udik3KWSacJOLEfoL/CXvh7PyVnPjMTJKlYp9upAjs994qUQULBZp4AxT78VhEn3rwv8lMBZUjQSgyJ0m5U/0JpHeT9Rcm3q9LQQDlNyoOH0M6adLyJ6t33BzbuNwFDqaHutCW+5FJcJkDFkwJqdadUxa/1bWP3CsrPHeBQjKRJyu503jvzhsPck/Z6lz2peZ+5nSZG5Rm9jz81SguDWdcO8lV+K9d27B3Gntr0ryPtVKlrhrzsPhR3MOU26rMfsgqVF8m4t9qJYOVh0Qt3xuNysZwzSzWzcujGoxuLmNvTS6+p7sRilXH8Xi31yQYwqxeUW13lo94ZiS+j2EB2a/V3Qyh9Iw7szOS+A0rDDUKRu9Xc+O3XLu4DKKqnvK9TlhPFoxwsT6T3zFYbMzF5bGcNPxiMMaHnvphQRRWuZ6mus6bqwrRXfP+Vu/tCs9ncPt0KiwRypTvyj3aOksXxiCSz2fQ3rd++wu2pYFyV0yGjwEFy0pcsFczq9OEg8g211zVR7Fpdh4RTy0Mrk5rN9YbxIkGkA9Zqeey7KvyroLNx+s+eXtip9FivyVLr39zbdvkSrBV25l57JceOthEEXO6ihRpzPfw8o0YmellRcaUquLjHvBqJPbwNRTrEzoPnSm7RExicbNJrqYjEX8ZpeXRYHkEm9oCg9yjpqeWfEr81ZdbjBfvaT7UFhaVeMRH191VRT10bvw1+Zx3T8bU1dje6gCjzjpd3CjTByJO4UgiQ/SMscrbl3GT84u2xD+P2KXgP7TB1H2uRfctUqzXrFGp6R2KwFUeJCEvupfNHpJGHvS5D/rqraTUOl8/va9VgMz3iW9tzlbCfPa1MhfrraLLOG0Gi3vom/opnto4EoXkFSWdc6tn0Aq0b2TdeH51TJNBfV+V3DrYAVQDOjd6Jo/Wu9ZFsSc/6o77Ov7ZClcT1Svl6LMZDmuG9B8l7u/i91vwO1v24RXnTZbtROwj+S26U/UgMRqP8F1YYyGt0o5ldC66kvtM/carfB8/WxxVG0fOnZmXHQJqVlSSCdLlEna9pk5Dq7Ka5/Jj4tFjgwtpUHI50Ns2H3pd229OAhd0mStWIxaXokZaK60Z9KZ/XVanMd6tRcPM/NZIVFI+DukpKyEpYfS+377dojF+XS/u+kISw/LZF5VfqCV1QS2ueb0FPAP8oSar6md7x0WzUu5HnidrBDNmWQz5lLqqDGRbqmYYuLEoq7u9ZFHKpWJ7/QpCzlE0z5AwI5vsTj4469CVL7RYxaBQOL32/GrpN73EHkLD6PVkInfmjq1Gfey9G2x0s58l1fmZV1w1gttSJDzD5n0WFsGBUxjxos4z5hIpdJZOBHvmZ0WGfTY8Ogn8cuRNwSvo84OrZRS5AruaocQ0kuWp1I531QdQW7j1MM/sP0ZgkL7F26MZOqutsTS3SHon2KjzXKbsYABVn+ME4GzaxMGXGJlGlJXiOn5JtLLSSHpneK/eiDjSZKh+r8Isl2TzbBY/6RhdKPEGk+ZuRoLd08RrPd2SfqUabm7PQ+fjVpFa+Ivp1yFzO4PyweO0GBzmXoyVMjPrKBgZouzLWMmIn5iuY8cqeOX3f2oJVHFXdpDfECLGFRpqJpEQU3YPL6u0MrhEyZoj/151s/4sJy0zz/VcdQFc80miDc7zOD0O9dNjN79RLlZJ8/PdZq5pR2aQnHNR6Hcdq1zb0kk35+GpQvx6PQ0ziHVc7IBIyt5jQ3/G3LPDcjVbYGFA+7Kpe9YTJT7+S99cnXC4Lj5r0vE3T5+L2PtjrX/rGR7nN5fU63EvysfmFsU3LhVbKEn1WTvNjDK4ooUNcxf1yrW6zzqXB5VXu3zR7wl3ZS/oi5cmJREK+aQldef9+4e4OTm302Lsr+rPJHSoRWVVv7Cd0LWa0MToHeVfeL+Brm/+rP/bOf+OQhPaagkSyU1fAaeVsNchDwKWegsX0g9KSHwJSRFuor3FAfH50rAArZOPu751ym1GXM8LxwGaMG4jR2nHWcpovL78KuHR3XKZeadERP4sRc9MVATfcB82CRDzrFscBkLKdFduk8Q7jkK3XJfuAN+m0UzUJ1ESfR0gEM2jVNya8fHeBmGhb35XEL2E0IQihb5GvtD2ZfZ6N1YiG1t8365jzaZzw5aexIA1F5soo5OnvnJe9lwg3eNxbfqbxnfcFdwQ9+2wPyOUSJGB1rRs3gSoJ1iEYEJoP7Bfn35L5K4ZHb8V3W9NdbBZsDmwmjRWP0m7Q5Jv8BEBNYIC2ebs5alvuFdtmNbuWDRgLZz1mSNyjwroCqXs63Oca3KWCTXsJhjrZtc1wt9Ne+5BW4WALv9AlCIl9p5U8ROpTzhcWV0FfPkROzhgrJ0ALMyODco+pnufqb0H4lTTHA1JwHSKWatTBIqNYVLyHxklCOQxMRGx28F3bpuOGF72V1jS9DcKqbG+noAxnFqD1G30SS9WHplhs0/q1l2ZaE4aZCAEAHClnlE2CUWu9eBs7c/mJ6cSP36Gx0GP7iisvIqSYzLRo0gfsmp+SzmUIkxtRfXCVNK+KpqgFympGbptQ3g1mxhC20h317PsdFsEjgQxv4Rzl2pmTYc0LB/XiVQoPzUyBHlNrkYHNenuK6MjouuJI8SMxsRhCLdNTnlVZSXOZY8Xr6sUfO1u5N14jIZanjapZ2cS8kI9dDhjt4hfxofKsCy8wsv/EpkgA1HNvdKG7MdndMjD6a4rdozXCug7vQiyZ7XSi7dLXZ6KYhxSmHH5YnvdPt90Z1IRR3htN4kiFpMg/PHs1ptF98GLZ+tjjPp1lmUNs1VNabjVpFGvOnztsGKyut8uO2LoqNT+fC2Mbf/hmD1kuoQSdJbmAUJKHOXaZRx5TC/i1e3EDTYzBaa2TkdXTASZFE2R5PukGUp0AsiiK6Zq9N2qZEGE85Ma/axOCMlMyA2TZyUArq+ftzhN3VG5vTBJJd4ZduMwyaKZbWZwH1ho4JAiAwE3rjAi1Ok+0MLVbduJfVcEyovxeYCIm7t27yqALxRm6EOQlmtbOar9mK9CzZTgqn1/lXvME4ILfsF2CxveLmtKoIixMv+bmxsWZOIi6La4m9HeretENZ+awRHJw7kPhQUZuWIoz0tFeo3prHL676yNovSvv4tySCvONshY8FOeqPRIwihkf+PU1kSwmbmW1+nx0DXwM64Uq1TMKG8sxcBHW88g3F2F7uVcWhR+Inniq85km5oppK6h3IR+sZlyEfRnLnehlJeB/ACvcISkUK0ieikI7uiNWOEyMXSyC2+97ulOtyOMhSOseK26yYpdu0AmKmQeYNaix9c7brrI6YuC6EWOUMkWFGc0daa0BjFW32aLJ4W/Rs+LyTCWLFUrZkwYpLsEDncNHZzKPedD6cclCsFKRTjjGdSRG6Lre14DEV3h3SIXsN28GOkd52GN64WhhX4mDmuIKtdTLpCsPFc3XPesMKM9zphvnLvVtS/MQRavrPriGJqe4qvq3ASh758nLrCaXVn3IOHyBwUFLju826P1Q9jEdIzX2I7TIwrE5AvF3N/aXdJumsnRlXzmnW4HHgyzK4yR8MGXoaOmZgvq6wu5sBG14dC6+6S6zO4xv2nQJtMtzLuhs6Z12wiTtqTDdw/YN/qj+e5XpN0JiA2ZttOmobpL+mZTMWsGrwj3IoMy0myK9bLDxVmfaQiH252qjRB/ylVd4dfSuQyXOXqNFNwam0E1N8ii3xFz8vG0fHJuPaBbdLB4Bn54a+qlTh4jNh//Gt184fPA9XiJXqTN4SUKV6Ev5+xWhlwayxo/NbR0XcARFiTfemSNU0yBIhzmUNESoDYY8sax4m5tgzijYVZ2sk8xv2XmhtYtO416I7+pqBsxX7sQhvtYQPcjO3f6bAobNlIeS08XyefcRpv9zGhtNpZnhDTdpzu+z1B8L8tc5aHn5eekQThfSTXsSO0vBfN+Zcr6fPutm95SCZ6CZFhdZFAinY5lERaoOvO2C6IiWJq7zymEdn+0HKTfn4tOLqoXr3MN6/5HCFn1kkqjNmnAhgtPaWhXX3csZ/XXhIfeS9cEdcpV3FF3gzwHltruVKxqYyI8eNJOdhYnX5TxY8tM7Wj+B4zAhKdqGXRxHSWsr5ZsCklCu87gaQ07F8vXCDcW6BF8ddxjrzogRx0iZln4erOPwkLSfG1vAjn/hVPEVR+d2815zjeCZvUp61VKl7Db1WZfPrVK33DnNyDDYD53XoObMNU9EvHN2Id6GuQ93Rv9Dx/P6JJ3uz5Off/QzL/JfBwzVhnsqGl/w99vjx1z/+bCav0D7w4Ipa2ZOHPoogHWAQcXMnUtQrxhzOPZ+6FXmeJSa4fINw02fOO8Acbpj2MFOFGylzz4sR7QTr32FX/TyYlB061kT7KgMv0e+OLMYXgp0D9WXjJ3o5Qxfajr22TN62TeLWeFvSFOgSwf6mFSj/dNRsMIOOG15ft9eVEFGxe4e3voQBHq6dgLtl3+uOSPg43jKkfapkXSZxFU+Jbyxc67NitjSoBoSCAUY0hDRoP8B6EbqpA8Bq9YWj1R42fczD7MrGacWUmP+D7KNjIijszcPUhB0xNFvOD9Ygyx5VkFDk+jhcCKMLnJnsIQY0VF2nQz183n2UEcap9we9ik5JqqIJF0Vk29LWIjZxBJbL4JLH4FNpXvz7EA9rX6zUiEq/FBu8niKetN8gnyTOw3jV7mpi4W+BSRa1F1LgYBdrccckrmX9yZKfUUSe4u6ZN/Mf6GE1JHVTjxNWxJkMP74VzQhP/bW5FEeFnsWzOxXzcHGerYQa4Q/Ci3FnoxyOy4jW1DUZ9OdSNZfjrauOj1WU8dm73oxt11IeP4muWRu5x3VQK1ISYpTkmjcrQEebMq5wq+vS0o4NBrLOLxOHPQQ0ylIxiVM2NtNxozZRi9h6d89Yp0ceajEb3RwsHuCPYIkyGh0ksN7IIgTD902Zr98oIvQiDHjW7QFTJzwd4e8qxYP+Tkrwt8dQ747hSUI1X3Yt37R6SMDJ60C1SGi65dQCD5jFDhhZjUgjihnp18+yntJXVvn23NZlSTVsZm/SqblOImBoGWcR105fmkgA+E4q/iKvPe7z7/SkRpYU6IXR0HdhhBJY1SJRspdKsvat1A+mC619K+JleYtbgWcmbwZb6Mo56tc6d71+NoeyPn89gk2R/zZdAY/cyrP3A4gWpLafsFbD015IS8qMXbMCliS1vCHxjU4aDOKRncqNMcksK6ekux95YXo/p1F3aMmcTzz7daVVFn6dUXz29vC7Q5c4UOXczfEh+redSrt96vU1mBpvqoonUUjWPA0hq1rj4rnLGaIK2HZiWMRO7l5z41X/WR2tnXpsEpmhns7dReQV1V16wkmL139jqC170nnlFi13t+UjigWuDrOsiy7QjDxF3GDYnUzfV2T8LnoE2zXh+utaqzktusk5sorPA+j/Xa4ECtOej2deaGgeBx52+KwbYuiwH261OJGty1o3r61gt5EmHBXXUv9gkIv9Uk3i1870WBjNZqU+f3QA/xPkZ3/guFF/5cBiRzkuGhTR/FMe49m1vC4ktsIrZM718IuD1HoEhhJvBwe7kjSYRQWCrQwDTQ8dKF7IWXsbbkqiXkRPcZwO80bBE6dC6Rb4SG5/aQ8obmscbl1BO99kxZlgtbPTjzp6CwtvWGBPUSAIBuHCXeXPiHoGCqZ2ABh0RD+MNAIAOwlRXYmtHq75CPHyqA+zhwapIy5Gzl8yqEyW2v+vN1m6q2bDzW1calMLuXzIiowSvhS6MYZfryyewiP+G0aIia5ceVp/0RTh8O9pyf+hDYpPE0PNRfvFLO4M2uS4dcxeCInwoGlV953kZaUlqbyR9MqsZS+5AQxYeTSEPcBrNBd0k+MlHotqCRVXvIJboXGRzpbJzsdDK3s9/qMtB+JXJsTGr2dWmttymvH+W/4ohHi/ICoUNT3bDHarelqq5p7Zp/LCjNWOfLzY/pLcodWSlv6AW3PUh7iNT6rpiSo3kTMGUw3UHqGqWZSyBKrRkYpttJGXvrZYgx+RHZ+tEgNYrAk7JdhNK7CLc/1oTh7CEGVAuMuG2tmUmLs9MjeZUDq/WCBUxly1e0HXrucWwo4ASyTtGDGdgy6s77dVAuhbCHIfRLPm9nO5cYLNTUJR6ZqFabYwG5d0WzqMnvnjDt3FMmhkaqywlGlpkZ74pL75TLkBa4DG4Ny9wWDOidL2L1HBCnFOz8UMmK002du/rkU+FYXnJPHadVUG+Fa25FP20RR88V7fYrVVyFIWYMNK7DGU8pjOwyn064ULJvVBD6f3SXGy5W0loeXI90TQoMdhup+Gph6a54p6Lw3s6TNZJztg14/UMy+EAW2ZV6xOS9AUPbGz7XP7XYEm6OdC1ag7ZtVrBMSoQikDeoqcxIbwvF2QznbX27Ls4trwjmb/evKjpLloNzzqRnbfNb096Xr2EuvIEbFNNMWKUD8T7SY4oQOkhmB1a8jNr5cQP1oBAuhHBF8dYE0eJbmBT7Dm1bkbkHtqt3muIbsHbLFMKsPNZLX3KUuS6SuYkM4z80u1BcfQNLFlWPIWXs0jnw27kFD0eXi6zCNZ0JzfEa+34GrrSVuV7xFrcLztROTxk86tFP38o0+PyEjYj6mxmBKtbmtzJcqQB/uRVcwLn9FRFFladxee47/74P3qIibClBZSVPpCeXI0iYjT7bcJR5JLgvQYQwK/ZY5q40xo6YlmGmITe93DR/p2XTUPJyC11l0mrEIGZkzGDWA1XHvauqYUnQk0x7d+jvk1zXYxQuIAEADepRTyvePx4yB3szS/iOiRD/LNaJ97if+z7yEa1DQMRF+rt9hz2C/5hQ/vxJuffH/2GyIf4+5GGf3ktQIcE/DPmd1fD34Q5b8BJAheNHAH5p9ft3tB/b9v77BweYF3r7j2jQJr4/j0MMFWf7R3F+ZuILTfWw/e11KKpyiMCxTXyPajIFVJPJkIDjGupCN/ywmSwDVMPvwhj6n2aTRzX/OlTzg5EBOExqfx6dDir6DOzRvzviC52jw+anLFA5kkYBTmJSexQVRigqwBkAfmdVaDaHb9y8AcXG6NggPziWehQnFihO08eD++cJU2heh30/eaB4KaIBp2KiehQ1Bihq6WcBuN1FoVkdfotwQLHCRgdO6i56FCE2KEL3jg32jyOZP+fFB8VrDk6o49GDfryMMAD4PUWhiR0+Fwn9eNUfG+QHpzGP4gSC4iSNCZzAQPTnvQVN6u3xUY7XUTegSFGdA07DO/TncLxQcA9PAPfdqcufJ1QMKqFoWMApe4ceRZcHim7AibBhYysKxXbnZIhHkf039GE/TSooaDds4LiOobAvbMxwADgMOmGdrmpgj/7Pg43Q+TnsaskNlR/688BpGHTCzgrpAgC/dSasE4jpsUF+eObw53B8UHBdJ4D7/swhdMcdPkwnA9VxUheB32Sd+X0boM64QbXBAxf4fV6U3zfj8JkzSahmWOABv8Ml8qj+F4Lqf3184FT9Gn+OKwGF23sauD846Aad+MNHr9ShEq9BAPx+v8bvm3P49JMuVHM6LgH/PRPD75t1+NyRFlSzhi8D/x0/Qdgn4b0rAPwuftC8D5/84YLirX8VOAUXv+/xDp/bObxInb8HIQRObpIH+8ufkgiAw+Hu59HpoaL7wB79+yMkP1+VsUP1z8QxIU7y6aVGDMBvbvdzEFYokA/HBvne3O7nqeOFSh0VCXA65nZHkWOHIvfk+JD/8LX7OT1+KHropMBp+dodRZATiqDv8UGP9XxBfwStwI/2naUdrB9BhmTA6Vrawb4+/XoC6O/d7H5O9yYUXfVrwGm72R1FmBt6YXQCcHPYOlcEejVODpyqkd1RVJmgqNYfA/mXAsdhgtAvc2YK4BQ87GBXaVJ/iPcT+7rvPnYPGb9BqzQ7vwx6PJUGekHQRAnAYSUHq8xBRwXAaSUHnZ3DnmPQMkfI8RDglzlsqAH4Dc1glTm+HBvkmDIHtBZwmwaA27sMVi2g5LgYJ9ECQLTASW3LYNUC4uGEOsmC9CIdAL9jGaxagPOxQU6kBWwfAw5+LUCXHji5PRnspbwOOOBOoAWIMACn5UwGqxbw/oSQJ9ECOBmBUzIlg3UZnHYyxF9rAYe9uqC1ABoQcFw/Mtjf/peZADjMv2Cdrpxgj/4rLeCw1xa0FtB/bJATagEuzAD8hl6wTiCDxwY5kRYgwwKcmqEXrFpA+UkxT0ELWGMFfp9DFuxawAgb8Du8q2DXArrZgVN1kYJVC5DnAH6LixSsWkDraeKfXAuQvAH896yVYNcCVLmA/47LEeyTMIQbgN9bCFYtoPvYICfTAqZ5gJNb98BerUjgBWD33YHmcNixBrpasfTLoCfZU1rBBxzXAwe64YftXeihGk7ED8DngQP7aktWAIDDNQbWWssb2KMfWWs5bEYCXWvBEgRO4hoD+9P9SQiA3+kEms1hRxHoT0JqYeDkTiewbyltPB7cr7aUHjbhgF4Qs4sAp2FaAnsVyVYUgNvpA9Yq0pfjYpykinRLDDipyQesVaS3cEKdpIpEdxOA398D1ipS+LFBTlRFunALOIGZB6xVJOfjo5ykijQHB9wJqkia4sBp+XjAWkVqPiHkSapIchLAKVl4wFpFKj8Z4q+rSIedLaCrSEKSwHHdO2Bf1zBLAXBYZcA6XYXBHv1XVaTDBhPQL821Y4OcsIpULw3A72IB6wQCkgFOw8UC1irSkxPAwVtFuiAL/CYXC9irSGJywO+zhYC9isQiD/wOwwbYq0g0CsCpWifAWkV6dhq4J6gikSkCv986AfYqUoIS8N/zE4C9ivRSGfjvXO0P+yRcqQLAf6E+rFUkGlXgFC7Uh72KxK0GnPy+etjLDnPHgIO+bB6a0OEr0NmgEiirDpzssnnYVzKVtwE4bliHdXvsNQ0A3hvWYd0e63dMiF+vKQ9faI4LhbXxD6zvLlf/PtThq0ygQ4VqAkffh35Uki9AJXkIAhx9E8p31a5DFzZAX1VAbQ/AdhPKUW3Dg2pbiBPwy3sfft7TxFDN6/lZrON9E5071MADIVZn4KdXPqCg/vGvEoAEYEwIAJyc//jT/xcAAP//bP+6O3C6AAA="); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } diff --git a/cmd/gf/internal/packed/template-single.go b/cmd/gf/internal/packed/template-single.go index aff784c45..9419e4682 100644 --- a/cmd/gf/internal/packed/template-single.go +++ b/cmd/gf/internal/packed/template-single.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("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"); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } diff --git a/cmd/gf/internal/utility/mlog/mlog.go b/cmd/gf/internal/utility/mlog/mlog.go index 4a2f146a8..4bf00c50d 100644 --- a/cmd/gf/internal/utility/mlog/mlog.go +++ b/cmd/gf/internal/utility/mlog/mlog.go @@ -3,7 +3,6 @@ package mlog import ( "context" - "github.com/gogf/gf/v2/frame/g" "github.com/gogf/gf/v2/os/gcmd" "github.com/gogf/gf/v2/os/genv" "github.com/gogf/gf/v2/os/glog" @@ -36,9 +35,9 @@ func init() { func SetHeaderPrint(enabled bool) { logger.SetHeaderPrint(enabled) if enabled { - genv.Set(headerPrintEnvName, "1") + _ = genv.Set(headerPrintEnvName, "1") } else { - genv.Set(headerPrintEnvName, "0") + _ = genv.Set(headerPrintEnvName, "0") } } @@ -51,17 +50,17 @@ func Printf(format string, v ...interface{}) { } func Fatal(v ...interface{}) { - logger.Fatal(ctx, append(g.Slice{"ERROR:"}, v...)...) + logger.Fatal(ctx, v...) } func Fatalf(format string, v ...interface{}) { - logger.Fatalf(ctx, "ERROR: "+format, v...) + logger.Fatalf(ctx, format, v...) } func Debug(v ...interface{}) { - logger.Debug(ctx, append(g.Slice{"DEBUG:"}, v...)...) + logger.Debug(ctx, v...) } func Debugf(format string, v ...interface{}) { - logger.Debugf(ctx, "DEBUG: "+format, v...) + logger.Debugf(ctx, format, v...) } From 308e13a54613783f7237cbabc27d6df825675fb4 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 28 Feb 2022 22:00:25 +0800 Subject: [PATCH 024/136] gf cli command build update --- cmd/gf/internal/cmd/cmd_build.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/gf/internal/cmd/cmd_build.go b/cmd/gf/internal/cmd/cmd_build.go index 871b49673..78e818177 100644 --- a/cmd/gf/internal/cmd/cmd_build.go +++ b/cmd/gf/internal/cmd/cmd_build.go @@ -115,7 +115,7 @@ type cBuildInput struct { Arch string `short:"a" name:"arch" brief:"output binary architecture, multiple arch separated with ','"` System string `short:"s" name:"system" brief:"output binary system, multiple os separated with ','"` Output string `short:"o" name:"output" brief:"output binary path, used when building single binary file"` - Path string `short:"p" name:"path" brief:"output binary directory path, default is './bin'" d:"./bin"` + Path string `short:"p" name:"path" brief:"output binary directory path, default is './temp'" d:"./temp"` Extra string `short:"e" name:"extra" brief:"extra custom \"go build\" options"` Mod string `short:"m" name:"mod" brief:"like \"-mod\" option of \"go build\", use \"-m none\" to disable go module"` Cgo bool `short:"c" name:"cgo" brief:"enable or disable cgo feature, it's disabled in default" orphan:"true"` From eb533f3344958fb7172a592d5036231aa84a818a Mon Sep 17 00:00:00 2001 From: huangqian Date: Mon, 28 Feb 2022 22:57:53 +0800 Subject: [PATCH 025/136] Improving gfile Code Coverage --- os/gfile/gfile_z_exmaple_basic_test.go | 5 ++++- os/gfile/gfile_z_unit_contents_test.go | 2 +- os/gfile/gfile_z_unit_copy_test.go | 9 +++++++-- os/gfile/gfile_z_unit_size_test.go | 5 +++++ os/gfile/gfile_z_unit_test.go | 13 +++++++++++++ 5 files changed, 30 insertions(+), 4 deletions(-) diff --git a/os/gfile/gfile_z_exmaple_basic_test.go b/os/gfile/gfile_z_exmaple_basic_test.go index 188d0a374..3f9d87ded 100644 --- a/os/gfile/gfile_z_exmaple_basic_test.go +++ b/os/gfile/gfile_z_exmaple_basic_test.go @@ -340,14 +340,17 @@ func ExampleIsReadable() { func ExampleIsWritable() { // init var ( - path = gfile.Pwd() + gfile.Separator + "testdata/readline/file.log" + path = gfile.Pwd() + gfile.Separator + "testdata/readline/" + file = "file.log" ) // Checks whether given `path` is writable. fmt.Println(gfile.IsWritable(path)) + fmt.Println(gfile.IsWritable(path + file)) // Output: // true + // true } func ExampleChmod() { diff --git a/os/gfile/gfile_z_unit_contents_test.go b/os/gfile/gfile_z_unit_contents_test.go index 3d38e18a6..bb9b01da3 100644 --- a/os/gfile/gfile_z_unit_contents_test.go +++ b/os/gfile/gfile_z_unit_contents_test.go @@ -323,7 +323,7 @@ func Test_Home(t *testing.T) { err error ) - reads, err = gfile.Home() + reads, err = gfile.Home("a", "b") t.Assert(err, nil) t.AssertNE(reads, "") }) diff --git a/os/gfile/gfile_z_unit_copy_test.go b/os/gfile/gfile_z_unit_copy_test.go index 73cb2689f..6a00895fa 100644 --- a/os/gfile/gfile_z_unit_copy_test.go +++ b/os/gfile/gfile_z_unit_copy_test.go @@ -28,7 +28,8 @@ func Test_Copy(t *testing.T) { defer delTestFiles(topath) t.Assert(gfile.IsFile(testpath()+topath), true) - t.AssertNE(gfile.Copy("", ""), nil) + t.AssertNE(gfile.Copy(paths, ""), nil) + t.AssertNE(gfile.Copy("", topath), nil) }) } @@ -46,7 +47,8 @@ func Test_CopyFile(t *testing.T) { defer delTestFiles(topath) t.Assert(gfile.IsFile(testpath()+topath), true) - t.AssertNE(gfile.CopyFile("", ""), nil) + t.AssertNE(gfile.CopyFile(paths, ""), nil) + t.AssertNE(gfile.CopyFile("", topath), nil) }) // Content replacement. gtest.C(t, func(t *gtest.T) { @@ -128,5 +130,8 @@ func Test_CopyDir(t *testing.T) { t.Assert(err, nil) t.Assert(gfile.GetContents(src), srcContent) t.Assert(gfile.GetContents(dst), srcContent) + + t.AssertNE(gfile.CopyDir(gfile.Dir(src), ""), nil) + t.AssertNE(gfile.CopyDir("", gfile.Dir(dst)), nil) }) } diff --git a/os/gfile/gfile_z_unit_size_test.go b/os/gfile/gfile_z_unit_size_test.go index f5f97c506..8e410a97b 100644 --- a/os/gfile/gfile_z_unit_size_test.go +++ b/os/gfile/gfile_z_unit_size_test.go @@ -68,6 +68,11 @@ func Test_StrToSize(t *testing.T) { t.Assert(gfile.StrToSize("8.53P"), gconv.Int64(8.53*1024*1024*1024*1024*1024)) t.Assert(gfile.StrToSize("8.53PB"), gconv.Int64(8.53*1024*1024*1024*1024*1024)) t.Assert(gfile.StrToSize("8.01EB"), gconv.Int64(8.01*1024*1024*1024*1024*1024*1024)) + t.Assert(gfile.StrToSize("0.01ZB"), gconv.Int64(0.01*1024*1024*1024*1024*1024*1024*1024)) + t.Assert(gfile.StrToSize("0.01YB"), gconv.Int64(0.01*1024*1024*1024*1024*1024*1024*1024*1024)) + t.Assert(gfile.StrToSize("0.01BB"), gconv.Int64(0.01*1024*1024*1024*1024*1024*1024*1024*1024*1024)) + t.Assert(gfile.StrToSize("0.01AB"), gconv.Int64(-1)) + t.Assert(gfile.StrToSize("123456789"), 123456789) }) } diff --git a/os/gfile/gfile_z_unit_test.go b/os/gfile/gfile_z_unit_test.go index 1b0c6596b..e290621e7 100644 --- a/os/gfile/gfile_z_unit_test.go +++ b/os/gfile/gfile_z_unit_test.go @@ -571,6 +571,7 @@ func Test_Dir(t *testing.T) { t.Assert(readlPath, testpath()) + t.Assert(len(gfile.Dir(".")) > 0, true) }) } @@ -667,3 +668,15 @@ func Test_MainPkgPath(t *testing.T) { t.Assert(reads, "") }) } + +func Test_SelfName(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + t.Assert(len(gfile.SelfName()) > 0, true) + }) +} + +func Test_MTimestamp(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + t.Assert(gfile.MTimestamp(gfile.Temp()) > 0, true) + }) +} From 88a9eef8a6cd1b8c3e77b0cba4e653662ca28a67 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 1 Mar 2022 11:43:42 +0800 Subject: [PATCH 026/136] api swagger ui update --- example/httpserver/swagger/config.yaml | 4 ++ example/httpserver/swagger/main.go | 38 +++++++++++++++++++ net/ghttp/ghttp_server.go | 2 +- net/ghttp/ghttp_server_swagger.go | 35 ++++++++++------- .../internal/swaggerui/swaggerui-packed.go | 9 ----- .../internal/swaggerui/swaggerui-redoc.go | 9 +++++ net/ghttp/internal/swaggerui/swaggerui.go | 8 +++- os/gres/gres_func_zip.go | 6 ++- protocol/goai/goai_shemaref.go | 8 ++++ util/gvalid/gvalid.go | 5 +++ util/gvalid/gvalid_z_unit_internal_test.go | 6 +++ 11 files changed, 104 insertions(+), 26 deletions(-) create mode 100644 example/httpserver/swagger/config.yaml create mode 100644 example/httpserver/swagger/main.go delete mode 100644 net/ghttp/internal/swaggerui/swaggerui-packed.go create mode 100644 net/ghttp/internal/swaggerui/swaggerui-redoc.go diff --git a/example/httpserver/swagger/config.yaml b/example/httpserver/swagger/config.yaml new file mode 100644 index 000000000..b15f8d007 --- /dev/null +++ b/example/httpserver/swagger/config.yaml @@ -0,0 +1,4 @@ +server: + address: ":8199" + openapiPath: "/api.json" + swaggerPath: "/swagger" \ No newline at end of file diff --git a/example/httpserver/swagger/main.go b/example/httpserver/swagger/main.go new file mode 100644 index 000000000..fad24f168 --- /dev/null +++ b/example/httpserver/swagger/main.go @@ -0,0 +1,38 @@ +package main + +import ( + "context" + "fmt" + + "github.com/gogf/gf/v2/frame/g" + "github.com/gogf/gf/v2/net/ghttp" +) + +type HelloReq struct { + g.Meta `path:"/hello" method:"get"` + Name string `v:"required" dc:"Your name"` +} +type HelloRes struct { + Reply string `dc:"Reply content"` +} + +type Hello struct{} + +func (Hello) Say(ctx context.Context, req *HelloReq) (res *HelloRes, err error) { + g.Log().Debugf(ctx, `receive say: %+v`, req) + res = &HelloRes{ + Reply: fmt.Sprintf(`Hi %s`, req.Name), + } + return +} + +func main() { + s := g.Server() + s.Use(ghttp.MiddlewareHandlerResponse) + s.Group("/", func(group *ghttp.RouterGroup) { + group.Bind( + new(Hello), + ) + }) + s.Run() +} diff --git a/net/ghttp/ghttp_server.go b/net/ghttp/ghttp_server.go index f036c121d..a731b31e6 100644 --- a/net/ghttp/ghttp_server.go +++ b/net/ghttp/ghttp_server.go @@ -16,6 +16,7 @@ import ( "strings" "time" + "github.com/gogf/gf/v2/net/ghttp/internal/swaggerui" "github.com/olekukonko/tablewriter" "github.com/gogf/gf/v2/container/garray" @@ -24,7 +25,6 @@ import ( "github.com/gogf/gf/v2/errors/gcode" "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/internal/intlog" - "github.com/gogf/gf/v2/net/ghttp/internal/swaggerui" "github.com/gogf/gf/v2/os/gcache" "github.com/gogf/gf/v2/os/genv" "github.com/gogf/gf/v2/os/gfile" diff --git a/net/ghttp/ghttp_server_swagger.go b/net/ghttp/ghttp_server_swagger.go index ea0cd34fc..7786a072b 100644 --- a/net/ghttp/ghttp_server_swagger.go +++ b/net/ghttp/ghttp_server_swagger.go @@ -7,14 +7,31 @@ package ghttp import ( - "net/http" - - "github.com/gogf/gf/v2/os/gfile" "github.com/gogf/gf/v2/text/gstr" ) const ( swaggerUIDefaultURL = `https://petstore.swagger.io/v2/swagger.json` + swaggerUITemplate = ` + + + + API Reference + + + + + + + + + +` ) // swaggerUI is a build-in hook handler for replace default swagger json URL to local openapi json file path. @@ -23,17 +40,9 @@ func (s *Server) swaggerUI(r *Request) { if s.config.OpenApiPath == "" { return } - var ( - indexFileName = `index.html` - ) - if r.StaticFile != nil && r.StaticFile.File != nil && gfile.Basename(r.StaticFile.File.Name()) == indexFileName { - if gfile.Basename(r.URL.Path) != indexFileName && r.originUrlPath[len(r.originUrlPath)-1] != '/' { - r.Response.Header().Set("Location", r.originUrlPath+"/") - r.Response.WriteHeader(http.StatusMovedPermanently) - r.ExitAll() - } + if r.StaticFile != nil && r.StaticFile.File != nil && r.StaticFile.IsDir { r.Response.Write(gstr.Replace( - string(r.StaticFile.File.Content()), + swaggerUITemplate, swaggerUIDefaultURL, s.config.OpenApiPath, )) diff --git a/net/ghttp/internal/swaggerui/swaggerui-packed.go b/net/ghttp/internal/swaggerui/swaggerui-packed.go deleted file mode 100644 index ed9e1c36f..000000000 --- a/net/ghttp/internal/swaggerui/swaggerui-packed.go +++ /dev/null @@ -1,9 +0,0 @@ -package swaggerui - -import "github.com/gogf/gf/v2/os/gres" - -func Init() { - if err := gres.Add("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"); err != nil { - panic("add binary content to resource manager failed: " + err.Error()) - } -} diff --git a/net/ghttp/internal/swaggerui/swaggerui-redoc.go b/net/ghttp/internal/swaggerui/swaggerui-redoc.go new file mode 100644 index 000000000..6a67c1159 --- /dev/null +++ b/net/ghttp/internal/swaggerui/swaggerui-redoc.go @@ -0,0 +1,9 @@ +package swaggerui + +import "github.com/gogf/gf/v2/os/gres" + +func Init() { + if err := gres.Add("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"); err != nil { + panic("add binary content to resource manager failed: " + err.Error()) + } +} diff --git a/net/ghttp/internal/swaggerui/swaggerui.go b/net/ghttp/internal/swaggerui/swaggerui.go index 1d5ac769c..613adedbb 100644 --- a/net/ghttp/internal/swaggerui/swaggerui.go +++ b/net/ghttp/internal/swaggerui/swaggerui.go @@ -6,6 +6,10 @@ // Package swaggerui provides packed swagger ui static files using resource manager. // -// Files from: https://github.com/swagger-api/swagger-ui -// Pack command: gf pack swagger-ui swaggerui-packed.go -n=swaggerui -p=/goframe/swaggerui +// Files from: +// https://github.com/Redocly/redoc +// https://www.jsdelivr.com/package/npm/redoc +// +// Pack command: +// gf pack redoc.standalone.js swaggerui-redoc.go -n=swaggerui -p=/goframe/swaggerui package swaggerui diff --git a/os/gres/gres_func_zip.go b/os/gres/gres_func_zip.go index 108852076..cb3ecb045 100644 --- a/os/gres/gres_func_zip.go +++ b/os/gres/gres_func_zip.go @@ -76,7 +76,11 @@ func doZipPathWriter(path string, exclude string, zipWriter *zip.Writer, prefix intlog.Printf(context.TODO(), `exclude file path: %s`, file) continue } - if err = zipFile(file, headerPrefix+gfile.Dir(file[len(path):]), zipWriter); err != nil { + subFilePath := file[len(path):] + if subFilePath != "" { + subFilePath = gfile.Dir(subFilePath) + } + if err = zipFile(file, headerPrefix+subFilePath, zipWriter); err != nil { return err } } diff --git a/protocol/goai/goai_shemaref.go b/protocol/goai/goai_shemaref.go index 14d356686..b6dd382b5 100644 --- a/protocol/goai/goai_shemaref.go +++ b/protocol/goai/goai_shemaref.go @@ -12,6 +12,7 @@ import ( "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/internal/json" "github.com/gogf/gf/v2/util/gconv" + "github.com/gogf/gf/v2/util/gvalid" ) type SchemaRefs []SchemaRef @@ -35,6 +36,13 @@ func (oai *OpenApiV3) newSchemaRefWithGolangType(golangType reflect.Type, tagMap if err := gconv.Struct(oai.fileMapWithShortTags(tagMap), schema); err != nil { return nil, gerror.Wrap(err, `mapping struct tags to Schema failed`) } + // Validation info to OpenAPI schema pattern. + for _, tag := range gvalid.GetTags() { + if validation, ok := tagMap[tag]; ok { + schema.Pattern = validation + break + } + } } schemaRef.Value = schema switch oaiType { diff --git a/util/gvalid/gvalid.go b/util/gvalid/gvalid.go index fed037efe..662a3c783 100644 --- a/util/gvalid/gvalid.go +++ b/util/gvalid/gvalid.go @@ -206,3 +206,8 @@ func parseSequenceTag(tag string) (field, rule, msg string) { match, _ := gregex.MatchString(`\s*((\w+)\s*@){0,1}\s*([^#]+)\s*(#\s*(.*)){0,1}\s*`, tag) return strings.TrimSpace(match[2]), strings.TrimSpace(match[3]), strings.TrimSpace(match[5]) } + +// GetTags returns the validation tags. +func GetTags() []string { + return structTagPriority +} diff --git a/util/gvalid/gvalid_z_unit_internal_test.go b/util/gvalid/gvalid_z_unit_internal_test.go index c1edc90ca..90fdbfb2a 100644 --- a/util/gvalid/gvalid_z_unit_internal_test.go +++ b/util/gvalid/gvalid_z_unit_internal_test.go @@ -42,3 +42,9 @@ func Test_parseSequenceTag(t *testing.T) { t.Assert(msg, "") }) } + +func Test_GetTags(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + t.Assert(structTagPriority, GetTags()) + }) +} From 50f6b6e0f043bb50b960a1e69330e95381ff8eba Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 1 Mar 2022 14:08:36 +0800 Subject: [PATCH 027/136] fix UT case for package ghttp --- net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go b/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go index 749d67732..a1ff87c45 100644 --- a/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go +++ b/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go @@ -62,7 +62,7 @@ func Test_OpenApi_Swagger(t *testing.T) { t.Assert(c.GetContent(ctx, "/test?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Age":18,"Name":"john"}}`) t.Assert(c.GetContent(ctx, "/test/error"), `{"code":50,"message":"error","data":null}`) - t.Assert(gstr.Contains(c.GetContent(ctx, "/swagger/"), `SwaggerUIBundle`), true) + t.Assert(gstr.Contains(c.GetContent(ctx, "/swagger/"), `API Reference`), true) t.Assert(gstr.Contains(c.GetContent(ctx, "/api.json"), `/test/error`), true) }) } From 2362c453ec1a03078a529966baacaceb7d2c6cd6 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 1 Mar 2022 16:39:47 +0800 Subject: [PATCH 028/136] improve cli command install --- cmd/gf/internal/service/install.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/cmd/gf/internal/service/install.go b/cmd/gf/internal/service/install.go index c5d3fec86..60957e278 100644 --- a/cmd/gf/internal/service/install.go +++ b/cmd/gf/internal/service/install.go @@ -181,13 +181,21 @@ func (s serviceInstall) getAvailablePaths() []serviceInstallAvailablePath { // Search and find the writable directory path. envPath := genv.Get("PATH", genv.Get("Path").String()).String() if gstr.Contains(envPath, ";") { + // windows. for _, v := range gstr.SplitAndTrim(envPath, ";") { + if v == "." { + continue + } folderPaths = s.checkAndAppendToAvailablePath( folderPaths, v, binaryFileName, ) } } else if gstr.Contains(envPath, ":") { + // *nix. for _, v := range gstr.SplitAndTrim(envPath, ":") { + if v == "." { + continue + } folderPaths = s.checkAndAppendToAvailablePath( folderPaths, v, binaryFileName, ) From 68bdf7deb4983c47dfbe3b8be18e206855f09426 Mon Sep 17 00:00:00 2001 From: med-one Date: Tue, 1 Mar 2022 18:32:11 +0800 Subject: [PATCH 029/136] revert(fix bug , add nexttime feature): ServeFileDownload File name Chinese garbled repair --- net/ghttp/ghttp_response.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_response.go b/net/ghttp/ghttp_response.go index eb6f89ef1..01312f0fd 100644 --- a/net/ghttp/ghttp_response.go +++ b/net/ghttp/ghttp_response.go @@ -11,6 +11,7 @@ import ( "bytes" "fmt" "net/http" + "net/url" "github.com/gogf/gf/v2/net/gtrace" "github.com/gogf/gf/v2/os/gfile" @@ -91,7 +92,7 @@ func (r *Response) ServeFileDownload(path string, name ...string) { } r.Header().Set("Content-Type", "application/force-download") r.Header().Set("Accept-Ranges", "bytes") - r.Header().Set("Content-Disposition", fmt.Sprintf(`attachment;filename="%s"`, downloadName)) + r.Header().Set("Content-Disposition", fmt.Sprintf(`attachment;filename="%s"`, url.QueryEscape(downloadName))) r.Server.serveFile(r.Request, serveFile) } From 12fdfbf8b2b1e66fdcd9d1f6490b457adce39bfe Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 1 Mar 2022 21:14:45 +0800 Subject: [PATCH 030/136] improve package gcfg --- os/gcfg/gcfg.go | 29 ++++--------- os/gcfg/gcfg_adapter_file.go | 3 +- os/gcfg/gcfg_adapter_file_content.go | 6 +-- os/gcfg/gcfg_adapter_file_path.go | 61 ++++++++++++++++++++-------- os/gcfg/gcfg_z_unit_basic_test.go | 16 +++++--- os/gcfg/gcfg_z_unit_instance_test.go | 10 +++-- os/gfile/gfile.go | 7 +++- 7 files changed, 79 insertions(+), 53 deletions(-) diff --git a/os/gcfg/gcfg.go b/os/gcfg/gcfg.go index 74cad55d0..c32f00d97 100644 --- a/os/gcfg/gcfg.go +++ b/os/gcfg/gcfg.go @@ -9,7 +9,6 @@ package gcfg import ( "context" - "fmt" "github.com/gogf/gf/v2/container/gvar" "github.com/gogf/gf/v2/errors/gcode" @@ -26,7 +25,8 @@ type Config struct { } const ( - DefaultName = "config" // DefaultName is the default group name for instance usage. + DefaultInstanceName = "config" // DefaultName is the default instance name for instance usage. + DefaultConfigFileName = "config" // DefaultConfigFile is the default configuration file name. ) // New creates and returns a Config object with default adapter of AdapterFile. @@ -52,31 +52,20 @@ func NewWithAdapter(adapter Adapter) *Config { // exists in the configuration directory, it then sets it as the default configuration file. The // toml file type is the default configuration file type. func Instance(name ...string) *Config { - var ( - ctx = context.TODO() - key = DefaultName - ) + var instanceName = DefaultInstanceName if len(name) > 0 && name[0] != "" { - key = name[0] + instanceName = name[0] } - return localInstances.GetOrSetFuncLock(key, func() interface{} { - adapter, err := NewAdapterFile() + return localInstances.GetOrSetFuncLock(instanceName, func() interface{} { + adapterFile, err := NewAdapterFile() if err != nil { intlog.Errorf(context.Background(), `%+v`, err) return nil } - // If it's not using default configuration or its configuration file is not available, - // it searches the possible configuration file according to the name and all supported - // file types. - if key != DefaultName || !adapter.Available(ctx) { - for _, fileType := range supportedFileTypes { - if file := fmt.Sprintf(`%s.%s`, key, fileType); adapter.Available(ctx, file) { - adapter.SetFileName(file) - break - } - } + if instanceName != DefaultInstanceName { + adapterFile.SetFileName(instanceName) } - return NewWithAdapter(adapter) + return NewWithAdapter(adapterFile) }).(*Config) } diff --git a/os/gcfg/gcfg_adapter_file.go b/os/gcfg/gcfg_adapter_file.go index 80ea4c4c7..795228432 100644 --- a/os/gcfg/gcfg_adapter_file.go +++ b/os/gcfg/gcfg_adapter_file.go @@ -30,7 +30,6 @@ type AdapterFile struct { } const ( - DefaultConfigFile = "config.toml" // DefaultConfigFile is the default configuration file name. commandEnvKeyForFile = "gf.gcfg.file" // commandEnvKeyForFile is the configuration key for command argument or environment configuring file name. commandEnvKeyForPath = "gf.gcfg.path" // commandEnvKeyForPath is the configuration key for command argument or environment configuring directory path. ) @@ -55,7 +54,7 @@ var ( func NewAdapterFile(file ...string) (*AdapterFile, error) { var ( err error - name = DefaultConfigFile + name = DefaultConfigFileName ) if len(file) > 0 { name = file[0] diff --git a/os/gcfg/gcfg_adapter_file_content.go b/os/gcfg/gcfg_adapter_file_content.go index f72f7ff09..b709fe393 100644 --- a/os/gcfg/gcfg_adapter_file_content.go +++ b/os/gcfg/gcfg_adapter_file_content.go @@ -15,7 +15,7 @@ import ( // SetContent sets customized configuration content for specified `file`. // The `file` is unnecessary param, default is DefaultConfigFile. func (c *AdapterFile) SetContent(content string, file ...string) { - name := DefaultConfigFile + name := DefaultConfigFileName if len(file) > 0 { name = file[0] } @@ -37,7 +37,7 @@ func (c *AdapterFile) SetContent(content string, file ...string) { // GetContent returns customized configuration content for specified `file`. // The `file` is unnecessary param, default is DefaultConfigFile. func (c *AdapterFile) GetContent(file ...string) string { - name := DefaultConfigFile + name := DefaultConfigFileName if len(file) > 0 { name = file[0] } @@ -47,7 +47,7 @@ func (c *AdapterFile) GetContent(file ...string) string { // RemoveContent removes the global configuration with specified `file`. // If `name` is not passed, it removes configuration of the default group name. func (c *AdapterFile) RemoveContent(file ...string) { - name := DefaultConfigFile + name := DefaultConfigFileName if len(file) > 0 { name = file[0] } diff --git a/os/gcfg/gcfg_adapter_file_path.go b/os/gcfg/gcfg_adapter_file_path.go index b23c682fc..c4149a983 100644 --- a/os/gcfg/gcfg_adapter_file_path.go +++ b/os/gcfg/gcfg_adapter_file_path.go @@ -138,21 +138,15 @@ func (c *AdapterFile) AddPath(path string) (err error) { return nil } -// GetFilePath returns the absolute configuration file path for the given filename by `file`. +// doGetFilePath returns the absolute configuration file path for the given filename by `file`. // If `file` is not passed, it returns the configuration file path of the default name. // It returns an empty `path` string and an error if the given `file` does not exist. -func (c *AdapterFile) GetFilePath(fileName ...string) (path string, err error) { - var ( - tempPath string - usedFileName = c.defaultName - ) - if len(fileName) > 0 { - usedFileName = fileName[0] - } +func (c *AdapterFile) doGetFilePath(fileName string) (path string) { + var tempPath string // Searching resource manager. if !gres.IsEmpty() { for _, tryFolder := range resourceTryFolders { - tempPath = tryFolder + usedFileName + tempPath = tryFolder + fileName if file := gres.Get(tempPath); file != nil { path = file.Name() return @@ -161,7 +155,7 @@ func (c *AdapterFile) GetFilePath(fileName ...string) (path string, err error) { c.searchPaths.RLockFunc(func(array []string) { for _, searchPath := range array { for _, tryFolder := range resourceTryFolders { - tempPath = searchPath + tryFolder + usedFileName + tempPath = searchPath + tryFolder + fileName if file := gres.Get(tempPath); file != nil { path = file.Name() return @@ -176,7 +170,7 @@ func (c *AdapterFile) GetFilePath(fileName ...string) (path string, err error) { // Searching local file system. if path == "" { // Absolute path. - if path = gfile.RealPath(usedFileName); path != "" { + if path = gfile.RealPath(fileName); path != "" { return } c.searchPaths.RLockFunc(func(array []string) { @@ -184,7 +178,7 @@ func (c *AdapterFile) GetFilePath(fileName ...string) (path string, err error) { searchPath = gstr.TrimRight(searchPath, `\/`) for _, tryFolder := range localSystemTryFolders { relativePath := gstr.TrimRight( - gfile.Join(tryFolder, usedFileName), + gfile.Join(tryFolder, fileName), `\/`, ) if path, _ = gspath.Search(searchPath, relativePath); path != "" { @@ -194,15 +188,48 @@ func (c *AdapterFile) GetFilePath(fileName ...string) (path string, err error) { } }) } + return +} +// GetFilePath returns the absolute configuration file path for the given filename by `file`. +// If `file` is not passed, it returns the configuration file path of the default name. +// It returns an empty `path` string and an error if the given `file` does not exist. +func (c *AdapterFile) GetFilePath(fileName ...string) (path string, err error) { + var ( + fileExtName string + tempFileName string + usedFileName = c.defaultName + ) + if len(fileName) > 0 { + usedFileName = fileName[0] + } + fileExtName = gfile.ExtName(usedFileName) + if path = c.doGetFilePath(usedFileName); path == "" && !gstr.InArray(supportedFileTypes, fileExtName) { + // If it's not using default configuration or its configuration file is not available, + // it searches the possible configuration file according to the name and all supported + // file types. + for _, fileType := range supportedFileTypes { + tempFileName = fmt.Sprintf(`%s.%s`, usedFileName, fileType) + if path = c.doGetFilePath(tempFileName); path != "" { + break + } + } + } // If it cannot find the path of `file`, it formats and returns a detailed error. if path == "" { var buffer = bytes.NewBuffer(nil) if c.searchPaths.Len() > 0 { - buffer.WriteString(fmt.Sprintf( - `config file "%s" not found in resource manager or the following system searching paths:`, - usedFileName, - )) + if !gstr.InArray(supportedFileTypes, fileExtName) { + buffer.WriteString(fmt.Sprintf( + `possible config files "%s" or "%s" not found in resource manager or following system searching paths:`, + usedFileName, fmt.Sprintf(`%s.%s`, usedFileName, gstr.Join(supportedFileTypes, "/")), + )) + } else { + buffer.WriteString(fmt.Sprintf( + `specified config file "%s" not found in resource manager or following system searching paths:`, + usedFileName, + )) + } c.searchPaths.RLockFunc(func(array []string) { index := 1 for _, searchPath := range array { diff --git a/os/gcfg/gcfg_z_unit_basic_test.go b/os/gcfg/gcfg_z_unit_basic_test.go index c9c11d24f..67ecbe29e 100644 --- a/os/gcfg/gcfg_z_unit_basic_test.go +++ b/os/gcfg/gcfg_z_unit_basic_test.go @@ -31,9 +31,11 @@ array = [1,2,3] cache = "127.0.0.1:6379,1" ` gtest.C(t, func(t *gtest.T) { - path := gcfg.DefaultConfigFile - err := gfile.PutContents(path, config) - t.Assert(err, nil) + var ( + path = gcfg.DefaultConfigFileName + err = gfile.PutContents(path, config) + ) + t.AssertNil(err) defer gfile.Remove(path) c, err := gcfg.New() @@ -47,9 +49,11 @@ array = [1,2,3] func Test_Basic2(t *testing.T) { config := `log-path = "logs"` gtest.C(t, func(t *gtest.T) { - path := gcfg.DefaultConfigFile - err := gfile.PutContents(path, config) - t.Assert(err, nil) + var ( + path = gcfg.DefaultConfigFileName + err = gfile.PutContents(path, config) + ) + t.AssertNil(err) defer func() { _ = gfile.Remove(path) }() diff --git a/os/gcfg/gcfg_z_unit_instance_test.go b/os/gcfg/gcfg_z_unit_instance_test.go index 2e7f0dc42..3cc5997b4 100644 --- a/os/gcfg/gcfg_z_unit_instance_test.go +++ b/os/gcfg/gcfg_z_unit_instance_test.go @@ -37,11 +37,13 @@ v4 = "1.234" ` gtest.C(t, func(t *gtest.T) { - path := DefaultConfigFile - err := gfile.PutContents(path, config) - t.Assert(err, nil) + var ( + path = DefaultConfigFileName + err = gfile.PutContents(path, config) + ) + t.AssertNil(err) defer func() { - t.Assert(gfile.Remove(path), nil) + t.AssertNil(gfile.Remove(path)) }() c := Instance() diff --git a/os/gfile/gfile.go b/os/gfile/gfile.go index 590112bf7..7d29a4279 100644 --- a/os/gfile/gfile.go +++ b/os/gfile/gfile.go @@ -417,8 +417,10 @@ func IsEmpty(path string) bool { // The extension is the suffix beginning at the final dot // in the final element of path; it is empty if there is // no dot. -// // Note: the result contains symbol '.'. +// Eg: +// main.go => .go +// api.json => .json func Ext(path string) string { ext := filepath.Ext(path) if p := strings.IndexByte(ext, '?'); p != -1 { @@ -429,6 +431,9 @@ func Ext(path string) string { // ExtName is like function Ext, which returns the file name extension used by path, // but the result does not contain symbol '.'. +// Eg: +// main.go => go +// api.json => json func ExtName(path string) string { return strings.TrimLeft(Ext(path), ".") } From 46dc68dfd58eb2bb18f23eaf97dc2aefc3307542 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 1 Mar 2022 21:20:17 +0800 Subject: [PATCH 031/136] CI update for gf cli --- .github/workflows/cli.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/cli.yml b/.github/workflows/cli.yml index 7269b096a..5019ddc0b 100644 --- a/.github/workflows/cli.yml +++ b/.github/workflows/cli.yml @@ -6,6 +6,10 @@ on: tags: - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10 +env: + TZ: Asia/Shanghai + + jobs: build: name: Build And Release From cb69fbcbd66d1888453a9dd372171305008ec3ce Mon Sep 17 00:00:00 2001 From: huangqian Date: Tue, 1 Mar 2022 22:12:59 +0800 Subject: [PATCH 032/136] Improving gSession Code Coverage --- os/gsession/gsession_z_example_test.go | 265 ++++++++++++++++++ .../gsession_z_unit_storage_file_test.go | 17 +- 2 files changed, 277 insertions(+), 5 deletions(-) create mode 100644 os/gsession/gsession_z_example_test.go diff --git a/os/gsession/gsession_z_example_test.go b/os/gsession/gsession_z_example_test.go new file mode 100644 index 000000000..469da26a4 --- /dev/null +++ b/os/gsession/gsession_z_example_test.go @@ -0,0 +1,265 @@ +package gsession_test + +import ( + "fmt" + "github.com/gogf/gf/v2/database/gredis" + "github.com/gogf/gf/v2/os/gctx" + "github.com/gogf/gf/v2/os/gsession" + "time" +) + +func ExampleNew() { + manager := gsession.New(time.Second) + fmt.Println(manager.TTL()) + + // Output: + // 1s +} + +func ExampleManager_SetStorage() { + manager := gsession.New(time.Second) + manager.SetStorage(gsession.NewStorageMemory()) + fmt.Println(manager.TTL()) + + // Output: + // 1s +} + +func ExampleManager_GetStorage() { + manager := gsession.New(time.Second, gsession.NewStorageMemory()) + size, _ := manager.GetStorage().GetSize(gctx.New(), "id") + fmt.Println(size) + + // Output: + // -1 +} + +func ExampleManager_SetTTL() { + manager := gsession.New(time.Second) + manager.SetTTL(time.Minute) + fmt.Println(manager.TTL()) + + // Output: + // 1m0s +} + +func ExampleSession_Set() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + s := manager.New(gctx.New()) + fmt.Println(s.Set("key", "val") == nil) + + // Output: + // true +} + +func ExampleSession_SetMap() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + s := manager.New(gctx.New()) + fmt.Println(s.SetMap(map[string]interface{}{}) == nil) + + // Output: + // true +} + +func ExampleSession_Remove() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + s1 := manager.New(gctx.New()) + fmt.Println(s1.Remove("key")) + + s2 := manager.New(gctx.New(), "Remove") + fmt.Println(s2.Remove("key")) + + // Output: + // + // +} + +func ExampleSession_RemoveAll() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + s1 := manager.New(gctx.New()) + fmt.Println(s1.RemoveAll()) + + s2 := manager.New(gctx.New(), "Remove") + fmt.Println(s2.RemoveAll()) + + // Output: + // + // +} + +func ExampleSession_Id() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + s := manager.New(gctx.New(), "Id") + id, _ := s.Id() + fmt.Println(id) + + // Output: + // Id +} + +func ExampleSession_SetId() { + nilSession := &gsession.Session{} + fmt.Println(nilSession.SetId("id")) + + manager := gsession.New(time.Second, gsession.NewStorageFile()) + s := manager.New(gctx.New()) + s.Id() + fmt.Println(s.SetId("id")) + + // Output: + // + // session already started +} + +func ExampleSession_SetIdFunc() { + nilSession := &gsession.Session{} + fmt.Println(nilSession.SetIdFunc(func(ttl time.Duration) string { + return "id" + })) + + manager := gsession.New(time.Second, gsession.NewStorageFile()) + s := manager.New(gctx.New()) + s.Id() + fmt.Println(s.SetIdFunc(func(ttl time.Duration) string { + return "id" + })) + + // Output: + // + // session already started +} + +func ExampleSession_Data() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + + s1 := manager.New(gctx.New()) + data1, _ := s1.Data() + fmt.Println(data1) + + s2 := manager.New(gctx.New(), "id_data") + data2, _ := s2.Data() + fmt.Println(data2) + + // Output: + // map[] + // map[] +} + +func ExampleSession_Size() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + + s1 := manager.New(gctx.New()) + size1, _ := s1.Size() + fmt.Println(size1) + + s2 := manager.New(gctx.New(), "Size") + size2, _ := s2.Size() + fmt.Println(size2) + + // Output: + // 0 + // 0 +} + +func ExampleSession_Contains() { + manager := gsession.New(time.Second, gsession.NewStorageFile()) + + s1 := manager.New(gctx.New()) + notContains, _ := s1.Contains("Contains") + fmt.Println(notContains) + + s2 := manager.New(gctx.New(), "Contains") + contains, _ := s2.Contains("Contains") + fmt.Println(contains) + + // Output: + // false + // false +} + +func ExampleStorageFile_SetCryptoKey() { + storage := gsession.NewStorageFile() + storage.SetCryptoKey([]byte("key")) + + size, _ := storage.GetSize(gctx.New(), "id") + fmt.Println(size) + + // Output: + // -1 +} + +func ExampleStorageFile_SetCryptoEnabled() { + storage := gsession.NewStorageFile() + storage.SetCryptoEnabled(true) + + size, _ := storage.GetSize(gctx.New(), "id") + fmt.Println(size) + + // Output: + // -1 +} + +func ExampleStorageFile_UpdateTTL() { + var ( + ctx = gctx.New() + ) + storage := gsession.NewStorageFile() + fmt.Println(storage.UpdateTTL(ctx, "id", time.Minute)) + + // Output: + // +} + +func ExampleStorageRedis_Get() { + storage := gsession.NewStorageRedis(&gredis.Redis{}) + val, _ := storage.Get(gctx.New(), "id", "key") + fmt.Println(val) + + // Output: + // +} + +func ExampleStorageRedis_Data() { + storage := gsession.NewStorageRedis(&gredis.Redis{}) + val, _ := storage.Data(gctx.New(), "id") + fmt.Println(val) + + // Output: + // map[] +} + +func ExampleStorageRedis_GetSize() { + storage := gsession.NewStorageRedis(&gredis.Redis{}) + val, _ := storage.GetSize(gctx.New(), "id") + fmt.Println(val) + + // Output: + // -1 +} + +func ExampleStorageRedis_Remove() { + storage := gsession.NewStorageRedis(&gredis.Redis{}) + err := storage.Remove(gctx.New(), "id", "key") + fmt.Println(err != nil) + + // Output: + // true +} + +func ExampleStorageRedis_RemoveAll() { + storage := gsession.NewStorageRedis(&gredis.Redis{}) + err := storage.RemoveAll(gctx.New(), "id") + fmt.Println(err != nil) + + // Output: + // true +} + +func ExampleStorageRedis_UpdateTTL() { + storage := gsession.NewStorageRedis(&gredis.Redis{}) + err := storage.UpdateTTL(gctx.New(), "id", time.Minute) + fmt.Println(err) + + // Output: + // +} diff --git a/os/gsession/gsession_z_unit_storage_file_test.go b/os/gsession/gsession_z_unit_storage_file_test.go index 3f2b75db0..75e68a810 100644 --- a/os/gsession/gsession_z_unit_storage_file_test.go +++ b/os/gsession/gsession_z_unit_storage_file_test.go @@ -25,9 +25,15 @@ func Test_StorageFile(t *testing.T) { defer s.Close() s.Set("k1", "v1") s.Set("k2", "v2") + s.MustSet("k3", "v3") + s.MustSet("k4", "v4") s.SetMap(g.Map{ - "k3": "v3", - "k4": "v4", + "kmap1": "kval1", + "kmap2": "kval2", + }) + s.MustSetMap(g.Map{ + "kmap3": "kval3", + "kmap4": "kval4", }) t.Assert(s.IsDirty(), true) sessionId = s.MustId() @@ -40,16 +46,17 @@ func Test_StorageFile(t *testing.T) { t.Assert(s.MustGet("k2"), "v2") t.Assert(s.MustGet("k3"), "v3") t.Assert(s.MustGet("k4"), "v4") - t.Assert(len(s.MustData()), 4) + t.Assert(len(s.MustData()), 8) t.Assert(s.MustData()["k1"], "v1") t.Assert(s.MustData()["k4"], "v4") t.Assert(s.MustId(), sessionId) - t.Assert(s.MustSize(), 4) + t.Assert(s.MustSize(), 8) t.Assert(s.MustContains("k1"), true) t.Assert(s.MustContains("k3"), true) t.Assert(s.MustContains("k5"), false) s.Remove("k4") - t.Assert(s.MustSize(), 3) + s.MustRemove("k4") + t.Assert(s.MustSize(), 7) t.Assert(s.MustContains("k3"), true) t.Assert(s.MustContains("k4"), false) s.RemoveAll() From 1724a269576f3124f8210b1646213cdbb8b08b88 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 1 Mar 2022 22:34:57 +0800 Subject: [PATCH 033/136] improve package gcfg --- frame/gins/gins_z_unit_config_test.go | 15 +++++++------ os/gcfg/gcfg_adapter_file.go | 1 + os/gcfg/gcfg_adapter_file_path.go | 31 ++++++++++++++++++--------- 3 files changed, 30 insertions(+), 17 deletions(-) diff --git a/frame/gins/gins_z_unit_config_test.go b/frame/gins/gins_z_unit_config_test.go index 409fef420..1395e34d6 100644 --- a/frame/gins/gins_z_unit_config_test.go +++ b/frame/gins/gins_z_unit_config_test.go @@ -65,16 +65,15 @@ func Test_Config2(t *testing.T) { gtest.C(t, func(t *gtest.T) { var err error dirPath := gfile.Temp(gtime.TimestampNanoStr()) - err = gfile.Mkdir(dirPath) - t.Assert(err, nil) + t.AssertNil(gfile.Mkdir(dirPath)) defer gfile.Remove(dirPath) name := "config/config.toml" err = gfile.PutContents(gfile.Join(dirPath, name), configContent) - t.Assert(err, nil) + t.AssertNil(err) err = gins.Config().GetAdapter().(*gcfg.AdapterFile).AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gins.Config().GetAdapter().(*gcfg.AdapterFile).Clear() @@ -200,9 +199,11 @@ func Test_Config4(t *testing.T) { func Test_Basic2(t *testing.T) { config := `log-path = "logs"` gtest.C(t, func(t *gtest.T) { - path := gcfg.DefaultConfigFile - err := gfile.PutContents(path, config) - t.Assert(err, nil) + var ( + path = gcfg.DefaultConfigFileName + err = gfile.PutContents(path, config) + ) + t.AssertNil(err) defer func() { _ = gfile.Remove(path) }() diff --git a/os/gcfg/gcfg_adapter_file.go b/os/gcfg/gcfg_adapter_file.go index 795228432..c7d42ccbe 100644 --- a/os/gcfg/gcfg_adapter_file.go +++ b/os/gcfg/gcfg_adapter_file.go @@ -223,6 +223,7 @@ func (c *AdapterFile) getJson(fileName ...string) (configJson *gjson.Json, err e } else { usedFileName = c.defaultName } + // It uses json map to cache specified configuration file content. result := c.jsonMap.GetOrSetFuncLock(usedFileName, func() interface{} { var ( content string diff --git a/os/gcfg/gcfg_adapter_file_path.go b/os/gcfg/gcfg_adapter_file_path.go index c4149a983..bd83a3fe5 100644 --- a/os/gcfg/gcfg_adapter_file_path.go +++ b/os/gcfg/gcfg_adapter_file_path.go @@ -10,6 +10,7 @@ import ( "bytes" "context" "fmt" + "os" "github.com/gogf/gf/v2/errors/gcode" "github.com/gogf/gf/v2/errors/gerror" @@ -142,23 +143,33 @@ func (c *AdapterFile) AddPath(path string) (err error) { // If `file` is not passed, it returns the configuration file path of the default name. // It returns an empty `path` string and an error if the given `file` does not exist. func (c *AdapterFile) doGetFilePath(fileName string) (path string) { - var tempPath string + var ( + tempPath string + resFile *gres.File + fileInfo os.FileInfo + ) // Searching resource manager. if !gres.IsEmpty() { for _, tryFolder := range resourceTryFolders { tempPath = tryFolder + fileName - if file := gres.Get(tempPath); file != nil { - path = file.Name() - return + if resFile = gres.Get(tempPath); resFile != nil { + fileInfo, _ = resFile.Stat() + if fileInfo != nil && !fileInfo.IsDir() { + path = resFile.Name() + return + } } } c.searchPaths.RLockFunc(func(array []string) { for _, searchPath := range array { for _, tryFolder := range resourceTryFolders { tempPath = searchPath + tryFolder + fileName - if file := gres.Get(tempPath); file != nil { - path = file.Name() - return + if resFile = gres.Get(tempPath); resFile != nil { + fileInfo, _ = resFile.Stat() + if fileInfo != nil && !fileInfo.IsDir() { + path = resFile.Name() + return + } } } } @@ -170,7 +181,7 @@ func (c *AdapterFile) doGetFilePath(fileName string) (path string) { // Searching local file system. if path == "" { // Absolute path. - if path = gfile.RealPath(fileName); path != "" { + if path = gfile.RealPath(fileName); path != "" && !gfile.IsDir(path) { return } c.searchPaths.RLockFunc(func(array []string) { @@ -181,7 +192,7 @@ func (c *AdapterFile) doGetFilePath(fileName string) (path string) { gfile.Join(tryFolder, fileName), `\/`, ) - if path, _ = gspath.Search(searchPath, relativePath); path != "" { + if path, _ = gspath.Search(searchPath, relativePath); path != "" && !gfile.IsDir(path) { return } } @@ -204,7 +215,7 @@ func (c *AdapterFile) GetFilePath(fileName ...string) (path string, err error) { usedFileName = fileName[0] } fileExtName = gfile.ExtName(usedFileName) - if path = c.doGetFilePath(usedFileName); path == "" && !gstr.InArray(supportedFileTypes, fileExtName) { + if path = c.doGetFilePath(usedFileName); (path == "" || gfile.IsDir(path)) && !gstr.InArray(supportedFileTypes, fileExtName) { // If it's not using default configuration or its configuration file is not available, // it searches the possible configuration file according to the name and all supported // file types. From f8067f5dd5bb45b949d8dc66b6a10464949ace84 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 1 Mar 2022 22:53:19 +0800 Subject: [PATCH 034/136] improve package ghttp --- net/ghttp/ghttp_request_param_form.go | 4 ++-- net/ghttp/ghttp_request_param_param.go | 6 ++++-- net/ghttp/ghttp_request_param_query.go | 4 ++-- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/net/ghttp/ghttp_request_param_form.go b/net/ghttp/ghttp_request_param_form.go index 4cb710e9c..617301343 100644 --- a/net/ghttp/ghttp_request_param_form.go +++ b/net/ghttp/ghttp_request_param_form.go @@ -25,8 +25,8 @@ func (r *Request) SetForm(key string, value interface{}) { func (r *Request) GetForm(key string, def ...interface{}) *gvar.Var { r.parseForm() if len(r.formMap) > 0 { - if v, ok := r.formMap[key]; ok { - return gvar.New(v) + if value, ok := r.formMap[key]; ok { + return gvar.New(value) } } if len(def) > 0 { diff --git a/net/ghttp/ghttp_request_param_param.go b/net/ghttp/ghttp_request_param_param.go index 1cb86c985..a12088633 100644 --- a/net/ghttp/ghttp_request_param_param.go +++ b/net/ghttp/ghttp_request_param_param.go @@ -30,8 +30,10 @@ func (r *Request) SetParamMap(data map[string]interface{}) { // It returns `def` if `key` does not exist. // It returns nil if `def` is not passed. func (r *Request) GetParam(key string, def ...interface{}) *gvar.Var { - if r.paramsMap != nil { - return gvar.New(r.paramsMap[key]) + if len(r.paramsMap) > 0 { + if value, ok := r.paramsMap[key]; ok { + return gvar.New(value) + } } if len(def) > 0 { return gvar.New(def[0]) diff --git a/net/ghttp/ghttp_request_param_query.go b/net/ghttp/ghttp_request_param_query.go index 70ed03f1d..3510030db 100644 --- a/net/ghttp/ghttp_request_param_query.go +++ b/net/ghttp/ghttp_request_param_query.go @@ -29,8 +29,8 @@ func (r *Request) SetQuery(key string, value interface{}) { func (r *Request) GetQuery(key string, def ...interface{}) *gvar.Var { r.parseQuery() if len(r.queryMap) > 0 { - if v, ok := r.queryMap[key]; ok { - return gvar.New(v) + if value, ok := r.queryMap[key]; ok { + return gvar.New(value) } } if r.Method == "GET" { From 072d5f9760cc3f32868c2b997f8372d23331c967 Mon Sep 17 00:00:00 2001 From: yuzhan Date: Wed, 2 Mar 2022 09:56:58 +0800 Subject: [PATCH 035/136] make options public --- net/ghttp/ghttp_server_cookie.go | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/net/ghttp/ghttp_server_cookie.go b/net/ghttp/ghttp_server_cookie.go index b37492a4c..1e519d957 100644 --- a/net/ghttp/ghttp_server_cookie.go +++ b/net/ghttp/ghttp_server_cookie.go @@ -23,9 +23,9 @@ type Cookie struct { // CookieOptions provides security config for cookies type CookieOptions struct { - sameSite http.SameSite // cookie SameSite property - secure bool // cookie Secure property - httpOnly bool // cookie HttpOnly property + SameSite http.SameSite // cookie SameSite property + Secure bool // cookie Secure property + HttpOnly bool // cookie HttpOnly property } // cookieItem is the item stored in Cookie. @@ -96,15 +96,15 @@ func (c *Cookie) Set(key, value string) { c.request.Server.GetCookiePath(), c.request.Server.GetCookieMaxAge(), CookieOptions{ - sameSite: c.request.Server.GetCookieSameSite(), - secure: c.request.Server.GetCookieSecure(), - httpOnly: c.request.Server.GetCookieHttpOnly(), + SameSite: c.request.Server.GetCookieSameSite(), + Secure: c.request.Server.GetCookieSecure(), + HttpOnly: c.request.Server.GetCookieHttpOnly(), }, ) } // SetCookie sets cookie item with given domain, path and expiration age. -// The optional parameter `httpOnly` specifies if the cookie item is only available in HTTP, +// The optional parameter `options` specifies extra security configurations, // which is usually empty. func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration, options ...CookieOptions) { c.init() @@ -117,9 +117,9 @@ func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration Value: value, Path: path, Domain: domain, - HttpOnly: config.httpOnly, - SameSite: config.sameSite, - Secure: config.secure, + HttpOnly: config.HttpOnly, + SameSite: config.SameSite, + Secure: config.Secure, } if maxAge != 0 { httpCookie.Expires = time.Now().Add(maxAge) @@ -151,9 +151,9 @@ func (c *Cookie) SetSessionId(id string) { c.request.Server.GetCookiePath(), c.server.GetSessionCookieMaxAge(), CookieOptions{ - sameSite: c.request.Server.GetCookieSameSite(), - secure: c.request.Server.GetCookieSecure(), - httpOnly: c.request.Server.GetCookieHttpOnly(), + SameSite: c.request.Server.GetCookieSameSite(), + Secure: c.request.Server.GetCookieSecure(), + HttpOnly: c.request.Server.GetCookieHttpOnly(), }, ) } From 3c58b8d7faedaa1bed7de70626773dffb4f67432 Mon Sep 17 00:00:00 2001 From: John Guo Date: Wed, 2 Mar 2022 10:26:09 +0800 Subject: [PATCH 036/136] improve openapi --- protocol/goai/goai_response.go | 12 +++++++++--- protocol/goai/goai_shema.go | 4 +--- protocol/goai/goai_z_unit_test.go | 6 ++++++ 3 files changed, 16 insertions(+), 6 deletions(-) diff --git a/protocol/goai/goai_response.go b/protocol/goai/goai_response.go index a7a73620c..076dccfb7 100644 --- a/protocol/goai/goai_response.go +++ b/protocol/goai/goai_response.go @@ -12,6 +12,7 @@ import ( "github.com/gogf/gf/v2/internal/json" "github.com/gogf/gf/v2/os/gstructs" "github.com/gogf/gf/v2/text/gstr" + "github.com/gogf/gf/v2/util/gconv" ) // Response is specified by OpenAPI/Swagger 3.0 standard. @@ -59,10 +60,12 @@ func (oai *OpenApiV3) getResponseSchemaRef(in getResponseSchemaRefInput) (*Schem return nil, err } if in.CommonResponseDataField == "" && bizResponseStructSchemaRefExist { + // Normal response. for k, v := range bizResponseStructSchemaRef.Value.Properties { schema.Properties[k] = v } } else { + // Common response. structFields, _ := gstructs.Fields(gstructs.FieldsInput{ Pointer: in.CommonResponseObject, RecursiveOption: gstructs.RecursiveOptionEmbeddedNoTag, @@ -77,14 +80,17 @@ func (oai *OpenApiV3) getResponseSchemaRef(in getResponseSchemaRefInput) (*Schem switch len(dataFieldsPartsArray) { case 1: if structField.Name() == dataFieldsPartsArray[0] { + err = gconv.Struct(oai.fileMapWithShortTags(structField.TagMap()), bizResponseStructSchemaRef.Value) + if err != nil { + return nil, err + } schema.Properties[fieldName] = bizResponseStructSchemaRef break } default: + // Recursively creating common response object schema. if structField.Name() == dataFieldsPartsArray[0] { - var ( - structFieldInstance = reflect.New(structField.Type().Type).Elem() - ) + var structFieldInstance = reflect.New(structField.Type().Type).Elem() schemaRef, err := oai.getResponseSchemaRef(getResponseSchemaRefInput{ BusinessStructName: in.BusinessStructName, CommonResponseObject: structFieldInstance, diff --git a/protocol/goai/goai_shema.go b/protocol/goai/goai_shema.go index dceebdc5e..1d7708f07 100644 --- a/protocol/goai/goai_shema.go +++ b/protocol/goai/goai_shema.go @@ -142,9 +142,7 @@ func (oai *OpenApiV3) structToSchema(object interface{}) (*Schema, error) { if !gstr.IsLetterUpper(structField.Name()[0]) { continue } - var ( - fieldName = structField.Name() - ) + var fieldName = structField.Name() if jsonName := structField.TagJsonName(); jsonName != "" { fieldName = jsonName } diff --git a/protocol/goai/goai_z_unit_test.go b/protocol/goai/goai_z_unit_test.go index 9acda5b21..3ae7645d9 100644 --- a/protocol/goai/goai_z_unit_test.go +++ b/protocol/goai/goai_z_unit_test.go @@ -459,10 +459,16 @@ func TestOpenApiV3_CommonResponse(t *testing.T) { Object: f, }) t.AssertNil(err) + + //g.Dump(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties) // Schema asserts. t.Assert(len(oai.Components.Schemas), 3) t.Assert(len(oai.Paths), 1) t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties), 3) + t.Assert( + oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties["data"].Value.Description, + `Result data for certain request according API definition`, + ) }) } From 5c23c0cecd64a94c17b3a28afc3d2f9ba45b6414 Mon Sep 17 00:00:00 2001 From: med-one Date: Wed, 2 Mar 2022 11:00:04 +0800 Subject: [PATCH 037/136] fix(fix bug , add nexttime feature): ServeFileDownload filename double quotes cause underscores before and after the final file --- net/ghttp/ghttp_response.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_response.go b/net/ghttp/ghttp_response.go index 01312f0fd..6b01be340 100644 --- a/net/ghttp/ghttp_response.go +++ b/net/ghttp/ghttp_response.go @@ -92,7 +92,7 @@ func (r *Response) ServeFileDownload(path string, name ...string) { } r.Header().Set("Content-Type", "application/force-download") r.Header().Set("Accept-Ranges", "bytes") - r.Header().Set("Content-Disposition", fmt.Sprintf(`attachment;filename="%s"`, url.QueryEscape(downloadName))) + r.Header().Set("Content-Disposition", fmt.Sprintf(`attachment;filename=%s`, url.QueryEscape(downloadName))) r.Server.serveFile(r.Request, serveFile) } From 3bff71b3fc412a898807a75ca9d9fa0573a18bfe Mon Sep 17 00:00:00 2001 From: yuzhan Date: Wed, 2 Mar 2022 15:33:58 +0800 Subject: [PATCH 038/136] merge master and update unit test --- net/ghttp/ghttp_z_unit_feature_cookie_test.go | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/net/ghttp/ghttp_z_unit_feature_cookie_test.go b/net/ghttp/ghttp_z_unit_feature_cookie_test.go index 4271165cb..b6aa8fa8c 100644 --- a/net/ghttp/ghttp_z_unit_feature_cookie_test.go +++ b/net/ghttp/ghttp_z_unit_feature_cookie_test.go @@ -104,12 +104,10 @@ func Test_SetHttpCookie(t *testing.T) { } func Test_CookieOptionsDefault(t *testing.T) { - p, _ := ports.PopRand() - s := g.Server(p) + s := g.Server(guid.S()) s.BindHandler("/test", func(r *ghttp.Request) { r.Cookie.Set(r.Get("k").String(), r.Get("v").String()) }) - s.SetPort(p) s.SetDumpRouterMap(false) s.Start() defer s.Shutdown() @@ -118,7 +116,7 @@ func Test_CookieOptionsDefault(t *testing.T) { gtest.C(t, func(t *gtest.T) { client := g.Client() client.SetBrowserMode(true) - client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p)) + client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) r1, e1 := client.Get(ctx, "/test?k=key1&v=100") if r1 != nil { defer r1.Close() @@ -134,8 +132,7 @@ func Test_CookieOptionsDefault(t *testing.T) { } func Test_CookieOptions(t *testing.T) { - p, _ := ports.PopRand() - s := g.Server(p) + s := g.Server(guid.S()) s.SetConfigWithMap(g.Map{ "cookieSameSite": "lax", "cookieSecure": true, @@ -144,7 +141,6 @@ func Test_CookieOptions(t *testing.T) { s.BindHandler("/test", func(r *ghttp.Request) { r.Cookie.Set(r.Get("k").String(), r.Get("v").String()) }) - s.SetPort(p) s.SetDumpRouterMap(false) s.Start() defer s.Shutdown() @@ -153,7 +149,7 @@ func Test_CookieOptions(t *testing.T) { gtest.C(t, func(t *gtest.T) { client := g.Client() client.SetBrowserMode(true) - client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p)) + client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) r1, e1 := client.Get(ctx, "/test?k=key1&v=100") if r1 != nil { defer r1.Close() From d64898c59a584260d9e597dcfb11eeae74cb0b11 Mon Sep 17 00:00:00 2001 From: John Guo Date: Wed, 2 Mar 2022 20:00:40 +0800 Subject: [PATCH 039/136] improve package goai --- protocol/goai/goai_parameter.go | 3 +-- protocol/goai/goai_requestbody.go | 13 ++++++------ protocol/goai/goai_response.go | 8 ++----- protocol/goai/goai_shema.go | 22 +++++++++++++++++--- protocol/goai/goai_shemaref.go | 18 +++------------- util/gvalid/gvalid.go | 4 ++-- util/gvalid/gvalid_validator_check_map.go | 2 +- util/gvalid/gvalid_validator_check_struct.go | 6 +++--- util/gvalid/gvalid_z_unit_internal_test.go | 8 +++---- 9 files changed, 42 insertions(+), 42 deletions(-) diff --git a/protocol/goai/goai_parameter.go b/protocol/goai/goai_parameter.go index 082bd60e4..298b75821 100644 --- a/protocol/goai/goai_parameter.go +++ b/protocol/goai/goai_parameter.go @@ -54,8 +54,7 @@ func (oai *OpenApiV3) newParameterRefWithStructMethod(field gstructs.Field, path parameter.Name = field.Name() } if len(tagMap) > 0 { - err := gconv.Struct(oai.fileMapWithShortTags(tagMap), parameter) - if err != nil { + if err := gconv.Struct(oai.fileMapWithShortTags(tagMap), parameter); err != nil { return nil, gerror.Wrap(err, `mapping struct tags to Parameter failed`) } } diff --git a/protocol/goai/goai_requestbody.go b/protocol/goai/goai_requestbody.go index e3c47aa81..7cc91ca86 100644 --- a/protocol/goai/goai_requestbody.go +++ b/protocol/goai/goai_requestbody.go @@ -55,32 +55,33 @@ func (oai *OpenApiV3) getRequestSchemaRef(in getRequestSchemaRefInput) (*SchemaR return nil, err } if in.RequestDataField == "" && bizRequestStructSchemaRefExist { + // Normal request. for k, v := range bizRequestStructSchemaRef.Value.Properties { schema.Properties[k] = v } } else { + // Common request. structFields, _ := gstructs.Fields(gstructs.FieldsInput{ Pointer: in.RequestObject, RecursiveOption: gstructs.RecursiveOptionEmbeddedNoTag, }) for _, structField := range structFields { - var ( - fieldName = structField.Name() - ) + var fieldName = structField.Name() if jsonName := structField.TagJsonName(); jsonName != "" { fieldName = jsonName } switch len(dataFieldsPartsArray) { case 1: if structField.Name() == dataFieldsPartsArray[0] { + if err = oai.tagMapToSchema(structField.TagMap(), bizRequestStructSchemaRef.Value); err != nil { + return nil, err + } schema.Properties[fieldName] = bizRequestStructSchemaRef break } default: if structField.Name() == dataFieldsPartsArray[0] { - var ( - structFieldInstance = reflect.New(structField.Type().Type).Elem() - ) + var structFieldInstance = reflect.New(structField.Type().Type).Elem() schemaRef, err := oai.getRequestSchemaRef(getRequestSchemaRefInput{ BusinessStructName: in.BusinessStructName, RequestObject: structFieldInstance, diff --git a/protocol/goai/goai_response.go b/protocol/goai/goai_response.go index 076dccfb7..8b47e51e1 100644 --- a/protocol/goai/goai_response.go +++ b/protocol/goai/goai_response.go @@ -12,7 +12,6 @@ import ( "github.com/gogf/gf/v2/internal/json" "github.com/gogf/gf/v2/os/gstructs" "github.com/gogf/gf/v2/text/gstr" - "github.com/gogf/gf/v2/util/gconv" ) // Response is specified by OpenAPI/Swagger 3.0 standard. @@ -71,17 +70,14 @@ func (oai *OpenApiV3) getResponseSchemaRef(in getResponseSchemaRefInput) (*Schem RecursiveOption: gstructs.RecursiveOptionEmbeddedNoTag, }) for _, structField := range structFields { - var ( - fieldName = structField.Name() - ) + var fieldName = structField.Name() if jsonName := structField.TagJsonName(); jsonName != "" { fieldName = jsonName } switch len(dataFieldsPartsArray) { case 1: if structField.Name() == dataFieldsPartsArray[0] { - err = gconv.Struct(oai.fileMapWithShortTags(structField.TagMap()), bizResponseStructSchemaRef.Value) - if err != nil { + if err = oai.tagMapToSchema(structField.TagMap(), bizResponseStructSchemaRef.Value); err != nil { return nil, err } schema.Properties[fieldName] = bizResponseStructSchemaRef diff --git a/protocol/goai/goai_shema.go b/protocol/goai/goai_shema.go index 1d7708f07..b1ebe2429 100644 --- a/protocol/goai/goai_shema.go +++ b/protocol/goai/goai_shema.go @@ -15,6 +15,7 @@ import ( "github.com/gogf/gf/v2/text/gstr" "github.com/gogf/gf/v2/util/gconv" "github.com/gogf/gf/v2/util/gmeta" + "github.com/gogf/gf/v2/util/gvalid" ) type Schemas map[string]SchemaRef @@ -114,9 +115,8 @@ func (oai *OpenApiV3) structToSchema(object interface{}) (*Schema, error) { } ) if len(tagMap) > 0 { - err := gconv.Struct(oai.fileMapWithShortTags(tagMap), schema) - if err != nil { - return nil, gerror.Wrap(err, `mapping meta data tags to Schema failed`) + if err := oai.tagMapToSchema(tagMap, schema); err != nil { + return nil, err } } if schema.Type != "" && schema.Type != TypeObject { @@ -157,3 +157,19 @@ func (oai *OpenApiV3) structToSchema(object interface{}) (*Schema, error) { } return schema, nil } + +func (oai *OpenApiV3) tagMapToSchema(tagMap map[string]string, schema *Schema) error { + var mergedTagMap = oai.fileMapWithShortTags(tagMap) + if err := gconv.Struct(mergedTagMap, schema); err != nil { + return gerror.Wrap(err, `mapping struct tags to Schema failed`) + } + // Validation info to OpenAPI schema pattern. + for _, tag := range gvalid.GetTags() { + if validationTagValue, ok := tagMap[tag]; ok { + _, validationRule, _ := gvalid.ParseTagValue(validationTagValue) + schema.Pattern = validationRule + break + } + } + return nil +} diff --git a/protocol/goai/goai_shemaref.go b/protocol/goai/goai_shemaref.go index b6dd382b5..1fd6a8bfa 100644 --- a/protocol/goai/goai_shemaref.go +++ b/protocol/goai/goai_shemaref.go @@ -9,10 +9,7 @@ package goai import ( "reflect" - "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/internal/json" - "github.com/gogf/gf/v2/util/gconv" - "github.com/gogf/gf/v2/util/gvalid" ) type SchemaRefs []SchemaRef @@ -33,15 +30,8 @@ func (oai *OpenApiV3) newSchemaRefWithGolangType(golangType reflect.Type, tagMap } ) if len(tagMap) > 0 { - if err := gconv.Struct(oai.fileMapWithShortTags(tagMap), schema); err != nil { - return nil, gerror.Wrap(err, `mapping struct tags to Schema failed`) - } - // Validation info to OpenAPI schema pattern. - for _, tag := range gvalid.GetTags() { - if validation, ok := tagMap[tag]; ok { - schema.Pattern = validation - break - } + if err := oai.tagMapToSchema(tagMap, schema); err != nil { + return nil, err } } schemaRef.Value = schema @@ -90,9 +80,7 @@ func (oai *OpenApiV3) newSchemaRefWithGolangType(golangType reflect.Type, tagMap default: // Normal struct object. - var ( - structTypeName = oai.golangTypeToSchemaName(golangType) - ) + var structTypeName = oai.golangTypeToSchemaName(golangType) if _, ok := oai.Components.Schemas[structTypeName]; !ok { if err := oai.addSchema(reflect.New(golangType).Elem().Interface()); err != nil { return nil, err diff --git a/util/gvalid/gvalid.go b/util/gvalid/gvalid.go index 662a3c783..dfad6b7c4 100644 --- a/util/gvalid/gvalid.go +++ b/util/gvalid/gvalid.go @@ -198,9 +198,9 @@ var ( } ) -// parseSequenceTag parses one sequence tag to field, rule and error message. +// ParseTagValue parses one sequence tag to field, rule and error message. // The sequence tag is like: [alias@]rule[...#msg...] -func parseSequenceTag(tag string) (field, rule, msg string) { +func ParseTagValue(tag string) (field, rule, msg string) { // Complete sequence tag. // Example: name@required|length:2,20|password3|same:password1#||密码强度不足|两次密码不一致 match, _ := gregex.MatchString(`\s*((\w+)\s*@){0,1}\s*([^#]+)\s*(#\s*(.*)){0,1}\s*`, tag) diff --git a/util/gvalid/gvalid_validator_check_map.go b/util/gvalid/gvalid_validator_check_map.go index 83b7d4d17..db67a8d59 100644 --- a/util/gvalid/gvalid_validator_check_map.go +++ b/util/gvalid/gvalid_validator_check_map.go @@ -31,7 +31,7 @@ func (v *Validator) doCheckMap(ctx context.Context, params interface{}) Error { // Sequence has order for error results. case []string: for _, tag := range assertValue { - name, rule, msg := parseSequenceTag(tag) + name, rule, msg := ParseTagValue(tag) if len(name) == 0 { continue } diff --git a/util/gvalid/gvalid_validator_check_struct.go b/util/gvalid/gvalid_validator_check_struct.go index dda5e49da..3e4f8dcdc 100644 --- a/util/gvalid/gvalid_validator_check_struct.go +++ b/util/gvalid/gvalid_validator_check_struct.go @@ -58,7 +58,7 @@ func (v *Validator) doCheckStruct(ctx context.Context, object interface{}) Error // Sequence has order for error results. case []string: for _, tag := range assertValue { - name, rule, msg := parseSequenceTag(tag) + name, rule, msg := ParseTagValue(tag) if len(name) == 0 { continue } @@ -126,8 +126,8 @@ func (v *Validator) doCheckStruct(ctx context.Context, object interface{}) Error for _, field := range tagFields { var ( isMeta bool - fieldName = field.Name() // Attribute name. - name, rule, msg = parseSequenceTag(field.TagValue) // The `name` is different from `attribute alias`, which is used for validation only. + fieldName = field.Name() // Attribute name. + name, rule, msg = ParseTagValue(field.TagValue) // The `name` is different from `attribute alias`, which is used for validation only. ) if len(name) == 0 { if value, ok := fieldToAliasNameMap[fieldName]; ok { diff --git a/util/gvalid/gvalid_z_unit_internal_test.go b/util/gvalid/gvalid_z_unit_internal_test.go index 90fdbfb2a..4a86d5053 100644 --- a/util/gvalid/gvalid_z_unit_internal_test.go +++ b/util/gvalid/gvalid_z_unit_internal_test.go @@ -15,28 +15,28 @@ import ( func Test_parseSequenceTag(t *testing.T) { gtest.C(t, func(t *gtest.T) { s := "name@required|length:2,20|password3|same:password1#||密码强度不足|两次密码不一致" - field, rule, msg := parseSequenceTag(s) + field, rule, msg := ParseTagValue(s) t.Assert(field, "name") t.Assert(rule, "required|length:2,20|password3|same:password1") t.Assert(msg, "||密码强度不足|两次密码不一致") }) gtest.C(t, func(t *gtest.T) { s := "required|length:2,20|password3|same:password1#||密码强度不足|两次密码不一致" - field, rule, msg := parseSequenceTag(s) + field, rule, msg := ParseTagValue(s) t.Assert(field, "") t.Assert(rule, "required|length:2,20|password3|same:password1") t.Assert(msg, "||密码强度不足|两次密码不一致") }) gtest.C(t, func(t *gtest.T) { s := "required|length:2,20|password3|same:password1" - field, rule, msg := parseSequenceTag(s) + field, rule, msg := ParseTagValue(s) t.Assert(field, "") t.Assert(rule, "required|length:2,20|password3|same:password1") t.Assert(msg, "") }) gtest.C(t, func(t *gtest.T) { s := "required" - field, rule, msg := parseSequenceTag(s) + field, rule, msg := ParseTagValue(s) t.Assert(field, "") t.Assert(rule, "required") t.Assert(msg, "") From 4e2d3781455d5d8a577d8b13376d849d9b463985 Mon Sep 17 00:00:00 2001 From: John Guo Date: Wed, 2 Mar 2022 21:15:16 +0800 Subject: [PATCH 040/136] improve file uploading using strict route feature --- net/ghttp/ghttp_request_param_file.go | 6 +-- net/ghttp/ghttp_request_param_request.go | 18 +++++-- .../ghttp_z_unit_feature_request_file_test.go | 48 +++++++++++++++++++ protocol/goai/goai.go | 1 + protocol/goai/goai_parameter.go | 3 +- protocol/goai/goai_path.go | 10 +++- 6 files changed, 75 insertions(+), 11 deletions(-) diff --git a/net/ghttp/ghttp_request_param_file.go b/net/ghttp/ghttp_request_param_file.go index 0b624cb76..84952e274 100644 --- a/net/ghttp/ghttp_request_param_file.go +++ b/net/ghttp/ghttp_request_param_file.go @@ -23,8 +23,8 @@ import ( // UploadFile wraps the multipart uploading file with more and convenient features. type UploadFile struct { - *multipart.FileHeader - ctx context.Context + *multipart.FileHeader `json:"-"` + ctx context.Context } // UploadFiles is array type for *UploadFile. @@ -32,7 +32,7 @@ type UploadFiles []*UploadFile // Save saves the single uploading file to directory path and returns the saved file name. // -// The parameter `dirPath` should be a directory path or it returns error. +// The parameter `dirPath` should be a directory path, or it returns error. // // Note that it will OVERWRITE the target file if there's already a same name file exist. func (f *UploadFile) Save(dirPath string, randomlyRename ...bool) (filename string, err error) { diff --git a/net/ghttp/ghttp_request_param_request.go b/net/ghttp/ghttp_request_param_request.go index 035ba2c72..8874fa79c 100644 --- a/net/ghttp/ghttp_request_param_request.go +++ b/net/ghttp/ghttp_request_param_request.go @@ -66,14 +66,10 @@ func (r *Request) GetRequestMap(kvMap ...map[string]interface{}) map[string]inte var ( ok, filter bool ) - var length int if len(kvMap) > 0 && kvMap[0] != nil { - length = len(kvMap[0]) filter = true - } else { - length = len(r.routerMap) + len(r.queryMap) + len(r.formMap) + len(r.bodyMap) + len(r.paramsMap) } - m := make(map[string]interface{}, length) + m := make(map[string]interface{}) for k, v := range r.routerMap { if filter { if _, ok = kvMap[0][k]; !ok { @@ -114,6 +110,16 @@ func (r *Request) GetRequestMap(kvMap ...map[string]interface{}) map[string]inte } m[k] = v } + // File uploading. + if r.MultipartForm != nil { + for name := range r.MultipartForm.File { + if uploadFiles := r.GetUploadFiles(name); len(uploadFiles) == 1 { + m[name] = uploadFiles[0] + } else { + m[name] = uploadFiles + } + } + } // Check none exist parameters and assign it with default value. if filter { for k, v := range kvMap[0] { @@ -171,9 +177,11 @@ func (r *Request) doGetRequestStruct(pointer interface{}, mapping ...map[string] if data == nil { data = map[string]interface{}{} } + // Default struct values. if err = r.mergeDefaultStructValue(data, pointer); err != nil { return data, nil } + return data, gconv.Struct(data, pointer, mapping...) } diff --git a/net/ghttp/ghttp_z_unit_feature_request_file_test.go b/net/ghttp/ghttp_z_unit_feature_request_file_test.go index bf273f62a..509a01897 100644 --- a/net/ghttp/ghttp_z_unit_feature_request_file_test.go +++ b/net/ghttp/ghttp_z_unit_feature_request_file_test.go @@ -7,6 +7,7 @@ package ghttp_test import ( + "context" "fmt" "testing" "time" @@ -18,6 +19,7 @@ import ( "github.com/gogf/gf/v2/os/gtime" "github.com/gogf/gf/v2/test/gtest" "github.com/gogf/gf/v2/text/gstr" + "github.com/gogf/gf/v2/util/gmeta" "github.com/gogf/gf/v2/util/guid" ) @@ -169,3 +171,49 @@ func Test_Params_File_Batch(t *testing.T) { t.Assert(gfile.GetContents(dstPath2), gfile.GetContents(srcPath2)) }) } + +func Test_Params_Strict_Route_File_Single(t *testing.T) { + type Req struct { + gmeta.Meta `method:"post" mime:"multipart/form-data"` + File *ghttp.UploadFile `type:"file"` + } + type Res struct{} + + dstDirPath := gfile.Temp(gtime.TimestampNanoStr()) + s := g.Server(guid.S()) + s.BindHandler("/upload/single", func(ctx context.Context, req *Req) (res *Res, err error) { + var ( + r = g.RequestFromCtx(ctx) + file = req.File + ) + if file == nil { + r.Response.WriteExit("upload file cannot be empty") + } + name, err := file.Save(dstDirPath) + if err != nil { + r.Response.WriteExit(err) + } + r.Response.WriteExit(name) + return + }) + s.SetDumpRouterMap(false) + s.Start() + defer s.Shutdown() + time.Sleep(100 * time.Millisecond) + // normal name + gtest.C(t, func(t *gtest.T) { + client := g.Client() + client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) + + srcPath := gdebug.TestDataPath("upload", "file1.txt") + dstPath := gfile.Join(dstDirPath, "file1.txt") + content := client.PostContent(ctx, "/upload/single", g.Map{ + "file": "@file:" + srcPath, + }) + t.AssertNE(content, "") + t.AssertNE(content, "upload file cannot be empty") + t.AssertNE(content, "upload failed") + t.Assert(content, "file1.txt") + t.Assert(gfile.GetContents(dstPath), gfile.GetContents(srcPath)) + }) +} diff --git a/protocol/goai/goai.go b/protocol/goai/goai.go index 85409e922..90c4bf020 100644 --- a/protocol/goai/goai.go +++ b/protocol/goai/goai.go @@ -82,6 +82,7 @@ const ( TagNamePath = `path` TagNameMethod = `method` TagNameMime = `mime` + TagNameConsumes = `consumes` TagNameType = `type` TagNameDomain = `domain` TagNameValidate = `v` diff --git a/protocol/goai/goai_parameter.go b/protocol/goai/goai_parameter.go index 298b75821..082bd60e4 100644 --- a/protocol/goai/goai_parameter.go +++ b/protocol/goai/goai_parameter.go @@ -54,7 +54,8 @@ func (oai *OpenApiV3) newParameterRefWithStructMethod(field gstructs.Field, path parameter.Name = field.Name() } if len(tagMap) > 0 { - if err := gconv.Struct(oai.fileMapWithShortTags(tagMap), parameter); err != nil { + err := gconv.Struct(oai.fileMapWithShortTags(tagMap), parameter) + if err != nil { return nil, gerror.Wrap(err, `mapping struct tags to Parameter failed`) } } diff --git a/protocol/goai/goai_path.go b/protocol/goai/goai_path.go index d60b912e4..62f29f142 100644 --- a/protocol/goai/goai_path.go +++ b/protocol/goai/goai_path.go @@ -80,6 +80,7 @@ func (oai *OpenApiV3) addPath(in addPathInput) error { } var ( + mime string path = Path{} inputMetaMap = gmeta.Data(inputObject.Interface()) outputMetaMap = gmeta.Data(outputObject.Interface()) @@ -126,12 +127,17 @@ func (oai *OpenApiV3) addPath(in addPathInput) error { } if len(inputMetaMap) > 0 { - if err := gconv.Struct(oai.fileMapWithShortTags(inputMetaMap), &path); err != nil { + inputMetaMap = oai.fileMapWithShortTags(inputMetaMap) + if err := gconv.Struct(inputMetaMap, &path); err != nil { return gerror.Wrap(err, `mapping struct tags to Path failed`) } - if err := gconv.Struct(oai.fileMapWithShortTags(inputMetaMap), &operation); err != nil { + if err := gconv.Struct(inputMetaMap, &operation); err != nil { return gerror.Wrap(err, `mapping struct tags to Operation failed`) } + // Allowed request mime. + if mime = inputMetaMap[TagNameMime]; mime == "" { + mime = inputMetaMap[TagNameConsumes] + } } // ================================================================================================================= From b5855037f389a48760f01ae67e891b0186965853 Mon Sep 17 00:00:00 2001 From: huangqian Date: Wed, 2 Mar 2022 21:50:23 +0800 Subject: [PATCH 041/136] Improving gSession Code Coverage --- os/gsession/gsession_z_example_test.go | 110 ++++++++++++++++++++++++- 1 file changed, 108 insertions(+), 2 deletions(-) diff --git a/os/gsession/gsession_z_example_test.go b/os/gsession/gsession_z_example_test.go index 469da26a4..bc65361ac 100644 --- a/os/gsession/gsession_z_example_test.go +++ b/os/gsession/gsession_z_example_test.go @@ -2,6 +2,7 @@ package gsession_test import ( "fmt" + "github.com/gogf/gf/v2/container/gmap" "github.com/gogf/gf/v2/database/gredis" "github.com/gogf/gf/v2/os/gctx" "github.com/gogf/gf/v2/os/gsession" @@ -203,8 +204,11 @@ func ExampleStorageFile_UpdateTTL() { var ( ctx = gctx.New() ) + storage := gsession.NewStorageFile() - fmt.Println(storage.UpdateTTL(ctx, "id", time.Minute)) + fmt.Println(storage.UpdateTTL(ctx, "id", time.Second*15)) + + time.Sleep(time.Second * 11) // Output: // @@ -257,9 +261,111 @@ func ExampleStorageRedis_RemoveAll() { func ExampleStorageRedis_UpdateTTL() { storage := gsession.NewStorageRedis(&gredis.Redis{}) - err := storage.UpdateTTL(gctx.New(), "id", time.Minute) + err := storage.UpdateTTL(gctx.New(), "id", time.Second*15) fmt.Println(err) + time.Sleep(time.Second * 11) + // Output: // } + +func ExampleStorageRedisHashTable_Get() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + v, err := storage.Get(gctx.New(), "id", "key") + + fmt.Println(v) + fmt.Println(err) + + // Output: + // + // redis adapter not initialized, missing configuration or adapter register? +} + +func ExampleStorageRedisHashTable_Data() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + data, err := storage.Data(gctx.New(), "id") + + fmt.Println(data) + fmt.Println(err) + + // Output: + // map[] + // redis adapter not initialized, missing configuration or adapter register? +} + +func ExampleStorageRedisHashTable_GetSize() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + size, err := storage.GetSize(gctx.New(), "id") + + fmt.Println(size) + fmt.Println(err) + + // Output: + // -1 + // redis adapter not initialized, missing configuration or adapter register? +} + +func ExampleStorageRedisHashTable_Remove() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + err := storage.Remove(gctx.New(), "id", "key") + + fmt.Println(err) + + // Output: + // redis adapter not initialized, missing configuration or adapter register? +} + +func ExampleStorageRedisHashTable_RemoveAll() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + err := storage.RemoveAll(gctx.New(), "id") + + fmt.Println(err) + + // Output: + // redis adapter not initialized, missing configuration or adapter register? +} + +func ExampleStorageRedisHashTable_GetSession() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + strAnyMap := gmap.StrAnyMap{} + + data, err := storage.GetSession(gctx.New(), "id", time.Second, &strAnyMap) + + fmt.Println(data) + fmt.Println(err) + + // Output: + // + // redis adapter not initialized, missing configuration or adapter register? +} + +func ExampleStorageRedisHashTable_SetSession() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + strAnyMap := gmap.StrAnyMap{} + + err := storage.SetSession(gctx.New(), "id", &strAnyMap, time.Second) + + fmt.Println(err) + + // Output: + // redis adapter not initialized, missing configuration or adapter register? +} + +func ExampleStorageRedisHashTable_UpdateTTL() { + storage := gsession.NewStorageRedisHashTable(&gredis.Redis{}) + + err := storage.UpdateTTL(gctx.New(), "id", time.Second) + + fmt.Println(err) + + // Output: + // redis adapter not initialized, missing configuration or adapter register? +} From 3fcd6ef877565e39f46def153fe69c40c878499f Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 3 Mar 2022 21:03:42 +0800 Subject: [PATCH 042/136] fix issue orphan value parsing for sructured arguments of command for package gcmd --- os/gcmd/gcmd_command_object.go | 19 +++++++--- os/gcmd/gcmd_z_unit_feature_object1_test.go | 41 ++++++++++++++++++++- 2 files changed, 54 insertions(+), 6 deletions(-) diff --git a/os/gcmd/gcmd_command_object.go b/os/gcmd/gcmd_command_object.go index 9924f743e..faf9ce706 100644 --- a/os/gcmd/gcmd_command_object.go +++ b/os/gcmd/gcmd_command_object.go @@ -221,9 +221,7 @@ func newCommandFromMethod(object interface{}, method reflect.Value) (command *Co return } - var ( - inputObject reflect.Value - ) + var inputObject reflect.Value if method.Type().In(1).Kind() == reflect.Ptr { inputObject = reflect.New(method.Type().In(1).Elem()).Elem() } else { @@ -264,8 +262,19 @@ func newCommandFromMethod(object interface{}, method reflect.Value) (command *Co } } else { // Read argument from command line option name. - if arg.Orphan && parser.GetOpt(arg.Name) != nil { - data[arg.Name] = "true" + if arg.Orphan { + if orphanValue := parser.GetOpt(arg.Name); orphanValue != nil { + if orphanValue.String() == "" { + // Eg: gf -f + data[arg.Name] = "true" + } else { + // Adapter with common user habits. + // Eg: + // `gf -f=0`: which parameter `f` is parsed as false + // `gf -f=1`: which parameter `f` is parsed as true + data[arg.Name] = orphanValue.Bool() + } + } } } } diff --git a/os/gcmd/gcmd_z_unit_feature_object1_test.go b/os/gcmd/gcmd_z_unit_feature_object1_test.go index dcde693de..4ee725e2c 100644 --- a/os/gcmd/gcmd_z_unit_feature_object1_test.go +++ b/os/gcmd/gcmd_z_unit_feature_object1_test.go @@ -243,7 +243,7 @@ func Test_Command_Pointer(t *testing.T) { t.AssertNil(err) t.Assert(value, `{"Content":"john"}`) }) - return + gtest.C(t, func(t *gtest.T) { var ( ctx = gctx.New() @@ -257,3 +257,42 @@ func Test_Command_Pointer(t *testing.T) { t.Assert(value, `{"Content":"john"}`) }) } + +type TestCommandOrphan struct { + g.Meta `name:"root" root:"root"` +} + +type TestCommandOrphanIndexInput struct { + g.Meta `name:"index"` + Orphan1 bool `short:"n1" orphan:"true"` + Orphan2 bool `short:"n2" orphan:"true"` + Orphan3 bool `short:"n3" orphan:"true"` +} +type TestCommandOrphanIndexOutput struct { + Orphan1 bool + Orphan2 bool + Orphan3 bool +} + +func (c *TestCommandOrphan) Index(ctx context.Context, in TestCommandOrphanIndexInput) (out *TestCommandOrphanIndexOutput, err error) { + out = &TestCommandOrphanIndexOutput{ + Orphan1: in.Orphan1, + Orphan2: in.Orphan2, + Orphan3: in.Orphan3, + } + return +} +func Test_Command_Orphan_Parameter(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + var ctx = gctx.New() + cmd, err := gcmd.NewFromObject(TestCommandOrphan{}) + t.AssertNil(err) + + os.Args = []string{"root", "index", "-n1", "-n2=0", "-n3=1"} + value, err := cmd.RunWithValueError(ctx) + t.AssertNil(err) + t.Assert(value.(*TestCommandOrphanIndexOutput).Orphan1, true) + t.Assert(value.(*TestCommandOrphanIndexOutput).Orphan2, false) + t.Assert(value.(*TestCommandOrphanIndexOutput).Orphan3, true) + }) +} From 84c0f456c05ba884df9185a29055ca91fe9a2042 Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 3 Mar 2022 21:43:01 +0800 Subject: [PATCH 043/136] template pack update --- cmd/gf/internal/packed/template-mono.go | 2 +- cmd/gf/internal/packed/template-single.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/gf/internal/packed/template-mono.go b/cmd/gf/internal/packed/template-mono.go index 480a35936..b21df6ddc 100644 --- a/cmd/gf/internal/packed/template-mono.go +++ b/cmd/gf/internal/packed/template-mono.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("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"); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } diff --git a/cmd/gf/internal/packed/template-single.go b/cmd/gf/internal/packed/template-single.go index 9419e4682..152642675 100644 --- a/cmd/gf/internal/packed/template-single.go +++ b/cmd/gf/internal/packed/template-single.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("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"); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } From d5d199ebefd16f8a8190e7fe9203159faa232cf4 Mon Sep 17 00:00:00 2001 From: John Guo Date: Fri, 4 Mar 2022 11:36:05 +0800 Subject: [PATCH 044/136] Swagger UI updates --- net/ghttp/ghttp_server_swagger.go | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/net/ghttp/ghttp_server_swagger.go b/net/ghttp/ghttp_server_swagger.go index 7786a072b..846993c9a 100644 --- a/net/ghttp/ghttp_server_swagger.go +++ b/net/ghttp/ghttp_server_swagger.go @@ -11,8 +11,10 @@ import ( ) const ( - swaggerUIDefaultURL = `https://petstore.swagger.io/v2/swagger.json` - swaggerUITemplate = ` + swaggerUIDocName = `redoc.standalone.js` + swaggerUIDocNamePlaceHolder = `{SwaggerUIDocName}` + swaggerUIDocURLPlaceHolder = `{SwaggerUIDocUrl}` + swaggerUITemplate = ` @@ -27,8 +29,8 @@ const ( - - + + ` @@ -41,11 +43,11 @@ func (s *Server) swaggerUI(r *Request) { return } if r.StaticFile != nil && r.StaticFile.File != nil && r.StaticFile.IsDir { - r.Response.Write(gstr.Replace( - swaggerUITemplate, - swaggerUIDefaultURL, - s.config.OpenApiPath, - )) + content := gstr.ReplaceByMap(swaggerUITemplate, map[string]string{ + swaggerUIDocURLPlaceHolder: s.config.OpenApiPath, + swaggerUIDocNamePlaceHolder: gstr.TrimRight(r.GetUrl(), "/") + "/" + swaggerUIDocName, + }) + r.Response.Write(content) r.ExitAll() } } From 531cc7b86489d920183e3f0811e31da3070204ae Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 7 Mar 2022 09:57:51 +0800 Subject: [PATCH 045/136] fix issue in package gproc --- net/ghttp/ghttp_server.go | 2 +- os/gproc/gproc_comm.go | 10 ++++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/net/ghttp/ghttp_server.go b/net/ghttp/ghttp_server.go index a731b31e6..0961cba70 100644 --- a/net/ghttp/ghttp_server.go +++ b/net/ghttp/ghttp_server.go @@ -128,7 +128,7 @@ func (s *Server) Start() error { swaggerui.Init() s.AddStaticPath(s.config.SwaggerPath, swaggerUIPackedPath) s.BindHookHandler(s.config.SwaggerPath+"/*", HookBeforeServe, s.swaggerUI) - s.Logger().Debugf( + s.Logger().Infof( ctx, `swagger ui is serving at address: %s%s/`, s.getListenAddress(), diff --git a/os/gproc/gproc_comm.go b/os/gproc/gproc_comm.go index 546142a16..b547d31d7 100644 --- a/os/gproc/gproc_comm.go +++ b/os/gproc/gproc_comm.go @@ -107,10 +107,12 @@ func getCommPidFolderPath() (folderPath string, err error) { break } } - err = gerror.Newf( - `cannot find available folder for storing pid to port mapping files in paths: %+v`, - availablePaths, - ) + if commPidFolderPath == "" { + err = gerror.Newf( + `cannot find available folder for storing pid to port mapping files in paths: %+v`, + availablePaths, + ) + } }) folderPath = commPidFolderPath return From 8a27463e44687bbfd3539a7c4acf23b39eeee6d4 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 7 Mar 2022 17:39:41 +0800 Subject: [PATCH 046/136] ensure sequence for json.Marshal for gmap.ListMap/TreeMap --- container/gmap/gmap_list_map.go | 44 +++++++++++++++++---- container/gmap/gmap_z_example_list_test.go | 11 +++--- container/gmap/gmap_z_unit_list_map_test.go | 24 ++++++++++- container/gpool/gpool.go | 4 +- container/gtree/gtree_avltree.go | 23 ++++++++++- container/gtree/gtree_btree.go | 22 ++++++++++- container/gtree/gtree_redblacktree.go | 23 ++++++++++- 7 files changed, 129 insertions(+), 22 deletions(-) diff --git a/container/gmap/gmap_list_map.go b/container/gmap/gmap_list_map.go index eed95f1a6..9ab520629 100644 --- a/container/gmap/gmap_list_map.go +++ b/container/gmap/gmap_list_map.go @@ -7,6 +7,9 @@ package gmap import ( + "bytes" + "fmt" + "github.com/gogf/gf/v2/container/glist" "github.com/gogf/gf/v2/container/gvar" "github.com/gogf/gf/v2/internal/empty" @@ -15,6 +18,13 @@ import ( "github.com/gogf/gf/v2/util/gconv" ) +// ListMap is a map that preserves insertion-order. +// +// It is backed by a hash table to store values and doubly-linked list to store ordering. +// +// Structure is not thread safe. +// +// Reference: http://en.wikipedia.org/wiki/Associative_array type ListMap struct { mu rwmutex.RWMutex data map[interface{}]*glist.Element @@ -58,7 +68,7 @@ func (m *ListMap) IteratorAsc(f func(key interface{}, value interface{}) bool) { m.mu.RLock() defer m.mu.RUnlock() if m.list != nil { - node := (*gListMapNode)(nil) + var node *gListMapNode m.list.IteratorAsc(func(e *glist.Element) bool { node = e.Value.(*gListMapNode) return f(node.key, node.value) @@ -72,7 +82,7 @@ func (m *ListMap) IteratorDesc(f func(key interface{}, value interface{}) bool) m.mu.RLock() defer m.mu.RUnlock() if m.list != nil { - node := (*gListMapNode)(nil) + var node *gListMapNode m.list.IteratorDesc(func(e *glist.Element) bool { node = e.Value.(*gListMapNode) return f(node.key, node.value) @@ -146,8 +156,10 @@ func (m *ListMap) MapStrAny() map[string]interface{} { func (m *ListMap) FilterEmpty() { m.mu.Lock() if m.list != nil { - keys := make([]interface{}, 0) - node := (*gListMapNode)(nil) + var ( + keys = make([]interface{}, 0) + node *gListMapNode + ) m.list.IteratorAsc(func(e *glist.Element) bool { node = e.Value.(*gListMapNode) if empty.IsEmpty(node.value) { @@ -495,7 +507,7 @@ func (m *ListMap) Merge(other *ListMap) { other.mu.RLock() defer other.mu.RUnlock() } - node := (*gListMapNode)(nil) + var node *gListMapNode other.list.IteratorAsc(func(e *glist.Element) bool { node = e.Value.(*gListMapNode) if e, ok := m.data[node.key]; !ok { @@ -514,8 +526,26 @@ func (m *ListMap) String() string { } // MarshalJSON implements the interface MarshalJSON for json.Marshal. -func (m ListMap) MarshalJSON() ([]byte, error) { - return json.Marshal(gconv.Map(m.Map())) +func (m ListMap) MarshalJSON() (jsonBytes []byte, err error) { + if m.data == nil { + return []byte("null"), nil + } + buffer := bytes.NewBuffer(nil) + buffer.WriteByte('{') + m.Iterator(func(key, value interface{}) bool { + valueBytes, valueJsonErr := json.Marshal(value) + if valueJsonErr != nil { + err = valueJsonErr + return false + } + if buffer.Len() > 1 { + buffer.WriteByte(',') + } + buffer.WriteString(fmt.Sprintf(`"%v":%s`, key, valueBytes)) + return true + }) + buffer.WriteByte('}') + return buffer.Bytes(), nil } // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. diff --git a/container/gmap/gmap_z_example_list_test.go b/container/gmap/gmap_z_example_list_test.go index 0f6645d50..0fab8cd80 100644 --- a/container/gmap/gmap_z_example_list_test.go +++ b/container/gmap/gmap_z_example_list_test.go @@ -8,6 +8,7 @@ package gmap_test import ( "fmt" + "github.com/gogf/gf/v2/container/gmap" "github.com/gogf/gf/v2/frame/g" "github.com/gogf/gf/v2/internal/json" @@ -562,12 +563,10 @@ func ExampleListMap_String() { func ExampleListMap_MarshalJSON() { var m gmap.ListMap - m.Sets(g.MapAnyAny{ - "k1": "v1", - "k2": "v2", - "k3": "v3", - "k4": "v4", - }) + m.Set("k1", "v1") + m.Set("k2", "v2") + m.Set("k3", "v3") + m.Set("k4", "v4") bytes, err := json.Marshal(&m) if err == nil { diff --git a/container/gmap/gmap_z_unit_list_map_test.go b/container/gmap/gmap_z_unit_list_map_test.go index 433dd48d0..0605e20a1 100644 --- a/container/gmap/gmap_z_unit_list_map_test.go +++ b/container/gmap/gmap_z_unit_list_map_test.go @@ -190,8 +190,9 @@ func Test_ListMap_Json(t *testing.T) { } m1 := gmap.NewListMapFrom(data) b1, err1 := json.Marshal(m1) + t.AssertNil(err1) b2, err2 := json.Marshal(gconv.Map(data)) - t.Assert(err1, err2) + t.AssertNil(err2) t.Assert(b1, b2) }) // Unmarshal @@ -226,6 +227,27 @@ func Test_ListMap_Json(t *testing.T) { }) } +func Test_ListMap_Json_Sequence(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + m := gmap.NewListMap() + for i := 'z'; i >= 'a'; i-- { + m.Set(string(i), i) + } + b, err := json.Marshal(m) + t.AssertNil(err) + t.Assert(b, `{"z":122,"y":121,"x":120,"w":119,"v":118,"u":117,"t":116,"s":115,"r":114,"q":113,"p":112,"o":111,"n":110,"m":109,"l":108,"k":107,"j":106,"i":105,"h":104,"g":103,"f":102,"e":101,"d":100,"c":99,"b":98,"a":97}`) + }) + gtest.C(t, func(t *gtest.T) { + m := gmap.NewListMap() + for i := 'a'; i <= 'z'; i++ { + m.Set(string(i), i) + } + b, err := json.Marshal(m) + t.AssertNil(err) + t.Assert(b, `{"a":97,"b":98,"c":99,"d":100,"e":101,"f":102,"g":103,"h":104,"i":105,"j":106,"k":107,"l":108,"m":109,"n":110,"o":111,"p":112,"q":113,"r":114,"s":115,"t":116,"u":117,"v":118,"w":119,"x":120,"y":121,"z":122}`) + }) +} + func Test_ListMap_Pop(t *testing.T) { gtest.C(t, func(t *gtest.T) { m := gmap.NewListMapFrom(g.MapAnyAny{ diff --git a/container/gpool/gpool.go b/container/gpool/gpool.go index 12baececf..f96986301 100644 --- a/container/gpool/gpool.go +++ b/container/gpool/gpool.go @@ -109,7 +109,7 @@ func (p *Pool) Get() (interface{}, error) { if f.expireAt == 0 || f.expireAt > gtime.TimestampMilli() { return f.value, nil } else if p.ExpireFunc != nil { - // TODO: move expire function calling asynchronously from `Get` operation. + // TODO: move expire function calling asynchronously out from `Get` operation. p.ExpireFunc(f.value) } } else { @@ -129,7 +129,7 @@ func (p *Pool) Size() int { // Close closes the pool. If `p` has ExpireFunc, // then it automatically closes all items using this function before it's closed. -// Commonly you do not need call this function manually. +// Commonly you do not need to call this function manually. func (p *Pool) Close() { p.closed.Set(true) } diff --git a/container/gtree/gtree_avltree.go b/container/gtree/gtree_avltree.go index 23c9fa0c8..e7dc8f7e0 100644 --- a/container/gtree/gtree_avltree.go +++ b/container/gtree/gtree_avltree.go @@ -7,6 +7,7 @@ package gtree import ( + "bytes" "fmt" "github.com/gogf/gf/v2/container/gvar" @@ -780,8 +781,26 @@ func output(node *AVLTreeNode, prefix string, isTail bool, str *string) { } // MarshalJSON implements the interface MarshalJSON for json.Marshal. -func (tree AVLTree) MarshalJSON() ([]byte, error) { - return json.Marshal(tree.MapStrAny()) +func (tree AVLTree) MarshalJSON() (jsonBytes []byte, err error) { + if tree.root == nil { + return []byte("null"), nil + } + buffer := bytes.NewBuffer(nil) + buffer.WriteByte('{') + tree.Iterator(func(key, value interface{}) bool { + valueBytes, valueJsonErr := json.Marshal(value) + if valueJsonErr != nil { + err = valueJsonErr + return false + } + if buffer.Len() > 1 { + buffer.WriteByte(',') + } + buffer.WriteString(fmt.Sprintf(`"%v":%s`, key, valueBytes)) + return true + }) + buffer.WriteByte('}') + return buffer.Bytes(), nil } // getComparator returns the comparator if it's previously set, diff --git a/container/gtree/gtree_btree.go b/container/gtree/gtree_btree.go index 1123a9185..2f758ab6f 100644 --- a/container/gtree/gtree_btree.go +++ b/container/gtree/gtree_btree.go @@ -944,8 +944,26 @@ func (tree *BTree) deleteChild(node *BTreeNode, index int) { } // MarshalJSON implements the interface MarshalJSON for json.Marshal. -func (tree BTree) MarshalJSON() ([]byte, error) { - return json.Marshal(tree.MapStrAny()) +func (tree BTree) MarshalJSON() (jsonBytes []byte, err error) { + if tree.root == nil { + return []byte("null"), nil + } + buffer := bytes.NewBuffer(nil) + buffer.WriteByte('{') + tree.Iterator(func(key, value interface{}) bool { + valueBytes, valueJsonErr := json.Marshal(value) + if valueJsonErr != nil { + err = valueJsonErr + return false + } + if buffer.Len() > 1 { + buffer.WriteByte(',') + } + buffer.WriteString(fmt.Sprintf(`"%v":%s`, key, valueBytes)) + return true + }) + buffer.WriteByte('}') + return buffer.Bytes(), nil } // getComparator returns the comparator if it's previously set, diff --git a/container/gtree/gtree_redblacktree.go b/container/gtree/gtree_redblacktree.go index 01d875dcc..f614ebe77 100644 --- a/container/gtree/gtree_redblacktree.go +++ b/container/gtree/gtree_redblacktree.go @@ -7,6 +7,7 @@ package gtree import ( + "bytes" "fmt" "github.com/gogf/gf/v2/container/gvar" @@ -925,8 +926,26 @@ func (tree *RedBlackTree) nodeColor(node *RedBlackTreeNode) color { } // MarshalJSON implements the interface MarshalJSON for json.Marshal. -func (tree RedBlackTree) MarshalJSON() ([]byte, error) { - return json.Marshal(gconv.Map(tree.Map())) +func (tree RedBlackTree) MarshalJSON() (jsonBytes []byte, err error) { + if tree.root == nil { + return []byte("null"), nil + } + buffer := bytes.NewBuffer(nil) + buffer.WriteByte('{') + tree.Iterator(func(key, value interface{}) bool { + valueBytes, valueJsonErr := json.Marshal(value) + if valueJsonErr != nil { + err = valueJsonErr + return false + } + if buffer.Len() > 1 { + buffer.WriteByte(',') + } + buffer.WriteString(fmt.Sprintf(`"%v":%s`, key, valueBytes)) + return true + }) + buffer.WriteByte('}') + return buffer.Bytes(), nil } // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. From aea9f6fe18c269c1e3674e33505caa1fbc9a4c57 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 7 Mar 2022 19:46:05 +0800 Subject: [PATCH 047/136] keep sequence in attributes definition for oai.Schemas --- protocol/goai/goai_requestbody.go | 19 +++---- protocol/goai/goai_response.go | 19 +++---- protocol/goai/goai_shema.go | 19 ++++--- protocol/goai/goai_shemaref.go | 4 +- protocol/goai/goai_shemas.go | 64 +++++++++++++++++++++++ protocol/goai/goai_z_unit_test.go | 86 +++++++++++++++---------------- 6 files changed, 138 insertions(+), 73 deletions(-) create mode 100644 protocol/goai/goai_shemas.go diff --git a/protocol/goai/goai_requestbody.go b/protocol/goai/goai_requestbody.go index 7cc91ca86..1676623fc 100644 --- a/protocol/goai/goai_requestbody.go +++ b/protocol/goai/goai_requestbody.go @@ -47,18 +47,19 @@ func (oai *OpenApiV3) getRequestSchemaRef(in getRequestSchemaRefInput) (*SchemaR } var ( - dataFieldsPartsArray = gstr.Split(in.RequestDataField, ".") - bizRequestStructSchemaRef, bizRequestStructSchemaRefExist = oai.Components.Schemas[in.BusinessStructName] - schema, err = oai.structToSchema(in.RequestObject) + dataFieldsPartsArray = gstr.Split(in.RequestDataField, ".") + bizRequestStructSchemaRef = oai.Components.Schemas.Get(in.BusinessStructName) + schema, err = oai.structToSchema(in.RequestObject) ) if err != nil { return nil, err } - if in.RequestDataField == "" && bizRequestStructSchemaRefExist { + if in.RequestDataField == "" && bizRequestStructSchemaRef != nil { // Normal request. - for k, v := range bizRequestStructSchemaRef.Value.Properties { - schema.Properties[k] = v - } + bizRequestStructSchemaRef.Value.Properties.Iterator(func(key string, ref SchemaRef) bool { + schema.Properties.Set(key, ref) + return true + }) } else { // Common request. structFields, _ := gstructs.Fields(gstructs.FieldsInput{ @@ -76,7 +77,7 @@ func (oai *OpenApiV3) getRequestSchemaRef(in getRequestSchemaRefInput) (*SchemaR if err = oai.tagMapToSchema(structField.TagMap(), bizRequestStructSchemaRef.Value); err != nil { return nil, err } - schema.Properties[fieldName] = bizRequestStructSchemaRef + schema.Properties.Set(fieldName, *bizRequestStructSchemaRef) break } default: @@ -90,7 +91,7 @@ func (oai *OpenApiV3) getRequestSchemaRef(in getRequestSchemaRefInput) (*SchemaR if err != nil { return nil, err } - schema.Properties[fieldName] = *schemaRef + schema.Properties.Set(fieldName, *schemaRef) break } } diff --git a/protocol/goai/goai_response.go b/protocol/goai/goai_response.go index 8b47e51e1..059e4a443 100644 --- a/protocol/goai/goai_response.go +++ b/protocol/goai/goai_response.go @@ -51,18 +51,19 @@ func (oai *OpenApiV3) getResponseSchemaRef(in getResponseSchemaRefInput) (*Schem } var ( - dataFieldsPartsArray = gstr.Split(in.CommonResponseDataField, ".") - bizResponseStructSchemaRef, bizResponseStructSchemaRefExist = oai.Components.Schemas[in.BusinessStructName] - schema, err = oai.structToSchema(in.CommonResponseObject) + dataFieldsPartsArray = gstr.Split(in.CommonResponseDataField, ".") + bizResponseStructSchemaRef = oai.Components.Schemas.Get(in.BusinessStructName) + schema, err = oai.structToSchema(in.CommonResponseObject) ) if err != nil { return nil, err } - if in.CommonResponseDataField == "" && bizResponseStructSchemaRefExist { + if in.CommonResponseDataField == "" && bizResponseStructSchemaRef != nil { // Normal response. - for k, v := range bizResponseStructSchemaRef.Value.Properties { - schema.Properties[k] = v - } + bizResponseStructSchemaRef.Value.Properties.Iterator(func(key string, ref SchemaRef) bool { + schema.Properties.Set(key, ref) + return true + }) } else { // Common response. structFields, _ := gstructs.Fields(gstructs.FieldsInput{ @@ -80,7 +81,7 @@ func (oai *OpenApiV3) getResponseSchemaRef(in getResponseSchemaRefInput) (*Schem if err = oai.tagMapToSchema(structField.TagMap(), bizResponseStructSchemaRef.Value); err != nil { return nil, err } - schema.Properties[fieldName] = bizResponseStructSchemaRef + schema.Properties.Set(fieldName, *bizResponseStructSchemaRef) break } default: @@ -95,7 +96,7 @@ func (oai *OpenApiV3) getResponseSchemaRef(in getResponseSchemaRefInput) (*Schem if err != nil { return nil, err } - schema.Properties[fieldName] = *schemaRef + schema.Properties.Set(fieldName, *schemaRef) break } } diff --git a/protocol/goai/goai_shema.go b/protocol/goai/goai_shema.go index b1ebe2429..627c3e332 100644 --- a/protocol/goai/goai_shema.go +++ b/protocol/goai/goai_shema.go @@ -9,6 +9,7 @@ package goai import ( "reflect" + "github.com/gogf/gf/v2/container/gmap" "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/internal/utils" "github.com/gogf/gf/v2/os/gstructs" @@ -18,8 +19,6 @@ import ( "github.com/gogf/gf/v2/util/gvalid" ) -type Schemas map[string]SchemaRef - // Schema is specified by OpenAPI/Swagger 3.0 standard. type Schema struct { OneOf SchemaRefs `json:"oneOf,omitempty" yaml:"oneOf,omitempty"` @@ -78,8 +77,8 @@ func (oai *OpenApiV3) addSchema(object ...interface{}) error { } func (oai *OpenApiV3) doAddSchemaSingle(object interface{}) error { - if oai.Components.Schemas == nil { - oai.Components.Schemas = map[string]SchemaRef{} + if oai.Components.Schemas.refs == nil { + oai.Components.Schemas.refs = gmap.NewListMap() } var ( @@ -88,21 +87,21 @@ func (oai *OpenApiV3) doAddSchemaSingle(object interface{}) error { ) // Already added. - if _, ok := oai.Components.Schemas[structTypeName]; ok { + if oai.Components.Schemas.Get(structTypeName) != nil { return nil } // Take the holder first. - oai.Components.Schemas[structTypeName] = SchemaRef{} + oai.Components.Schemas.Set(structTypeName, SchemaRef{}) schema, err := oai.structToSchema(object) if err != nil { return err } - oai.Components.Schemas[structTypeName] = SchemaRef{ + oai.Components.Schemas.Set(structTypeName, SchemaRef{ Ref: "", Value: schema, - } + }) return nil } @@ -111,7 +110,7 @@ func (oai *OpenApiV3) structToSchema(object interface{}) (*Schema, error) { var ( tagMap = gmeta.Data(object) schema = &Schema{ - Properties: map[string]SchemaRef{}, + Properties: createSchemas(), } ) if len(tagMap) > 0 { @@ -153,7 +152,7 @@ func (oai *OpenApiV3) structToSchema(object interface{}) (*Schema, error) { if err != nil { return nil, err } - schema.Properties[fieldName] = *schemaRef + schema.Properties.Set(fieldName, *schemaRef) } return schema, nil } diff --git a/protocol/goai/goai_shemaref.go b/protocol/goai/goai_shemaref.go index 1fd6a8bfa..ec6207c6e 100644 --- a/protocol/goai/goai_shemaref.go +++ b/protocol/goai/goai_shemaref.go @@ -70,7 +70,7 @@ func (oai *OpenApiV3) newSchemaRefWithGolangType(golangType reflect.Type, tagMap var ( structTypeName = oai.golangTypeToSchemaName(golangType) ) - if _, ok := oai.Components.Schemas[structTypeName]; !ok { + if oai.Components.Schemas.Get(structTypeName) == nil { if err := oai.addSchema(reflect.New(golangType).Interface()); err != nil { return nil, err } @@ -81,7 +81,7 @@ func (oai *OpenApiV3) newSchemaRefWithGolangType(golangType reflect.Type, tagMap default: // Normal struct object. var structTypeName = oai.golangTypeToSchemaName(golangType) - if _, ok := oai.Components.Schemas[structTypeName]; !ok { + if oai.Components.Schemas.Get(structTypeName) == nil { if err := oai.addSchema(reflect.New(golangType).Elem().Interface()); err != nil { return nil, err } diff --git a/protocol/goai/goai_shemas.go b/protocol/goai/goai_shemas.go new file mode 100644 index 000000000..c25b8ce00 --- /dev/null +++ b/protocol/goai/goai_shemas.go @@ -0,0 +1,64 @@ +// Copyright GoFrame Author(https://goframe.org). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with this file, +// You can obtain one at https://github.com/gogf/gf. + +package goai + +import ( + "github.com/gogf/gf/v2/container/gmap" +) + +type Schemas struct { + refs *gmap.ListMap +} + +func createSchemas() Schemas { + return Schemas{ + refs: gmap.NewListMap(), + } +} + +func (s *Schemas) init() { + if s.refs == nil { + s.refs = gmap.NewListMap() + } +} + +func (s Schemas) Get(name string) *SchemaRef { + s.init() + value := s.refs.Get(name) + if value != nil { + ref := value.(SchemaRef) + return &ref + } + return nil +} + +func (s Schemas) Set(name string, ref SchemaRef) { + s.init() + s.refs.Set(name, ref) +} + +func (s Schemas) Map() map[string]SchemaRef { + s.init() + m := make(map[string]SchemaRef) + s.refs.Iterator(func(key, value interface{}) bool { + m[key.(string)] = value.(SchemaRef) + return true + }) + return m +} + +func (s Schemas) Iterator(f func(key string, ref SchemaRef) bool) { + s.init() + s.refs.Iterator(func(key, value interface{}) bool { + return f(key.(string), value.(SchemaRef)) + }) +} + +func (s Schemas) MarshalJSON() ([]byte, error) { + s.init() + return s.refs.MarshalJSON() +} diff --git a/protocol/goai/goai_z_unit_test.go b/protocol/goai/goai_z_unit_test.go index 3ae7645d9..7c734f74a 100644 --- a/protocol/goai/goai_z_unit_test.go +++ b/protocol/goai/goai_z_unit_test.go @@ -48,14 +48,14 @@ func Test_Basic(t *testing.T) { }) t.AssertNil(err) // Schema asserts. - t.Assert(len(oai.Components.Schemas), 2) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Type, goai.TypeObject) - t.Assert(len(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Properties), 7) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Properties[`appId`].Value.Type, goai.TypeNumber) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Properties[`resourceId`].Value.Type, goai.TypeString) + t.Assert(len(oai.Components.Schemas.Map()), 2) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Type, goai.TypeObject) + t.Assert(len(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Properties.Map()), 7) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Properties.Get(`appId`).Value.Type, goai.TypeNumber) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Properties.Get(`resourceId`).Value.Type, goai.TypeString) - t.Assert(len(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`].Value.Properties), 3) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`].Value.Properties[`Params`].Value.Type, goai.TypeArray) + t.Assert(len(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`).Value.Properties.Map()), 3) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`).Value.Properties.Get(`Params`).Value.Type, goai.TypeArray) }) } @@ -108,14 +108,14 @@ func TestOpenApiV3_Add(t *testing.T) { t.AssertNil(err) // fmt.Println(oai.String()) // Schema asserts. - t.Assert(len(oai.Components.Schemas), 3) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Type, goai.TypeObject) - t.Assert(len(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Properties), 7) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Properties[`appId`].Value.Type, goai.TypeNumber) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`].Value.Properties[`resourceId`].Value.Type, goai.TypeString) + t.Assert(len(oai.Components.Schemas.Map()), 3) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Type, goai.TypeObject) + t.Assert(len(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Properties.Map()), 7) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Properties.Get(`appId`).Value.Type, goai.TypeNumber) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`).Value.Properties.Get(`resourceId`).Value.Type, goai.TypeString) - t.Assert(len(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`].Value.Properties), 3) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`].Value.Properties[`Params`].Value.Type, goai.TypeArray) + t.Assert(len(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`).Value.Properties.Map()), 3) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo`).Value.Properties.Get(`Params`).Value.Type, goai.TypeArray) // Paths. t.Assert(len(oai.Paths), 1) @@ -158,9 +158,9 @@ func TestOpenApiV3_Add_Recursive(t *testing.T) { }) t.AssertNil(err) // Schema asserts. - t.Assert(len(oai.Components.Schemas), 3) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CategoryTreeItem`].Value.Type, goai.TypeObject) - t.Assert(len(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CategoryTreeItem`].Value.Properties), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CategoryTreeItem`).Value.Type, goai.TypeObject) + t.Assert(len(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CategoryTreeItem`).Value.Properties.Map()), 3) }) } @@ -222,7 +222,7 @@ func TestOpenApiV3_Add_AutoDetectIn(t *testing.T) { fmt.Println(oai.String()) - t.Assert(len(oai.Components.Schemas), 2) + t.Assert(len(oai.Components.Schemas.Map()), 2) t.Assert(len(oai.Paths), 1) t.AssertNE(oai.Paths[path].Get, nil) t.Assert(len(oai.Paths[path].Get.Parameters), 3) @@ -274,9 +274,9 @@ func TestOpenApiV3_CommonRequest(t *testing.T) { }) t.AssertNil(err) // Schema asserts. - t.Assert(len(oai.Components.Schemas), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) t.Assert(len(oai.Paths), 1) - t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties), 3) + t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties.Map()), 3) }) } @@ -319,9 +319,9 @@ func TestOpenApiV3_CommonRequest_WithoutDataField_Setting(t *testing.T) { t.AssertNil(err) // Schema asserts. // fmt.Println(oai.String()) - t.Assert(len(oai.Components.Schemas), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) t.Assert(len(oai.Paths), 1) - t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties), 5) + t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties.Map()), 5) }) } @@ -359,9 +359,9 @@ func TestOpenApiV3_CommonRequest_EmptyRequest(t *testing.T) { t.AssertNil(err) // Schema asserts. // fmt.Println(oai.String()) - t.Assert(len(oai.Components.Schemas), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) t.Assert(len(oai.Paths), 1) - t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties), 3) + t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties.Map()), 3) }) } @@ -414,10 +414,10 @@ func TestOpenApiV3_CommonRequest_SubDataField(t *testing.T) { t.AssertNil(err) // Schema asserts. // fmt.Println(oai.String()) - t.Assert(len(oai.Components.Schemas), 4) + t.Assert(len(oai.Components.Schemas.Map()), 4) t.Assert(len(oai.Paths), 1) - t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties), 1) - t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties[`Request`].Value.Properties), 4) + t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties.Map()), 1) + t.Assert(len(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Value.Properties.Get(`Request`).Value.Properties.Map()), 4) }) } @@ -460,13 +460,13 @@ func TestOpenApiV3_CommonResponse(t *testing.T) { }) t.AssertNil(err) - //g.Dump(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties) + //g.Dump(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties.Map()) // Schema asserts. - t.Assert(len(oai.Components.Schemas), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) t.Assert(len(oai.Paths), 1) - t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties), 3) + t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties.Map()), 3) t.Assert( - oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties["data"].Value.Description, + oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties.Get("data").Value.Description, `Result data for certain request according API definition`, ) }) @@ -511,9 +511,9 @@ func TestOpenApiV3_CommonResponse_WithoutDataField_Setting(t *testing.T) { t.AssertNil(err) // Schema asserts. fmt.Println(oai.String()) - t.Assert(len(oai.Components.Schemas), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) t.Assert(len(oai.Paths), 1) - t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties), 8) + t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties.Map()), 8) }) } @@ -551,10 +551,10 @@ func TestOpenApiV3_CommonResponse_EmptyResponse(t *testing.T) { t.AssertNil(err) // Schema asserts. // fmt.Println(oai.String()) - t.Assert(len(oai.Components.Schemas), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) t.Assert(len(oai.Paths), 1) t.Assert(oai.Paths["/index"].Put.RequestBody.Value.Content["application/json"].Schema.Ref, `github.com.gogf.gf.v2.protocol.goai_test.Req`) - t.Assert(len(oai.Paths["/index"].Put.Responses["200"].Value.Content["application/json"].Schema.Value.Properties), 3) + t.Assert(len(oai.Paths["/index"].Put.Responses["200"].Value.Content["application/json"].Schema.Value.Properties.Map()), 3) }) } @@ -607,10 +607,10 @@ func TestOpenApiV3_CommonResponse_SubDataField(t *testing.T) { t.AssertNil(err) // Schema asserts. // fmt.Println(oai.String()) - t.Assert(len(oai.Components.Schemas), 4) + t.Assert(len(oai.Components.Schemas.Map()), 4) t.Assert(len(oai.Paths), 1) - t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties), 1) - t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties[`Response`].Value.Properties), 7) + t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties.Map()), 1) + t.Assert(len(oai.Paths["/index"].Get.Responses["200"].Value.Content["application/json"].Schema.Value.Properties.Get(`Response`).Value.Properties.Map()), 7) }) } @@ -663,12 +663,12 @@ func TestOpenApiV3_ShortTags(t *testing.T) { t.AssertNil(err) // fmt.Println(oai.String()) // Schema asserts. - t.Assert(len(oai.Components.Schemas), 3) + t.Assert(len(oai.Components.Schemas.Map()), 3) t.Assert(oai.Paths[`/test1/{appId}`].Summary, `CreateResourceReq sum`) t.Assert(oai. Components. - Schemas[`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`]. - Value.Properties[`resourceId`].Value.Description, `资源Id`) + Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq`). + Value.Properties.Get(`resourceId`).Value.Description, `资源Id`) }) } @@ -698,7 +698,7 @@ func TestOpenApiV3_HtmlResponse(t *testing.T) { t.AssertNil(err) // fmt.Println(oai.String()) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.Res`].Value.Type, goai.TypeString) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.Res`).Value.Type, goai.TypeString) }) } @@ -745,6 +745,6 @@ func TestOpenApiV3_HtmlResponseWithCommonResponse(t *testing.T) { t.AssertNil(err) // fmt.Println(oai.String()) - t.Assert(oai.Components.Schemas[`github.com.gogf.gf.v2.protocol.goai_test.Res`].Value.Type, goai.TypeString) + t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.Res`).Value.Type, goai.TypeString) }) } From 6d323cc5290f09553d62233b51708e44756026cb Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 7 Mar 2022 20:49:30 +0800 Subject: [PATCH 048/136] improve package goai --- protocol/goai/goai.go | 7 +++-- protocol/goai/goai_parameter.go | 12 +++++--- protocol/goai/goai_requestbody.go | 1 - protocol/goai/goai_shema.go | 23 ++++++++++++-- protocol/goai/goai_z_unit_test.go | 51 +++++++++++++++++++++++++++++++ 5 files changed, 85 insertions(+), 9 deletions(-) diff --git a/protocol/goai/goai.go b/protocol/goai/goai.go index 90c4bf020..235acc8ff 100644 --- a/protocol/goai/goai.go +++ b/protocol/goai/goai.go @@ -43,7 +43,6 @@ type ExternalDocs struct { } const ( - HttpMethodAll = `ALL` HttpMethodGet = `GET` HttpMethodPut = `PUT` HttpMethodPost = `POST` @@ -85,7 +84,11 @@ const ( TagNameConsumes = `consumes` TagNameType = `type` TagNameDomain = `domain` - TagNameValidate = `v` +) + +const ( + patternKeyForRequired = `required` + patternKeyForIn = `in:` ) var ( diff --git a/protocol/goai/goai_parameter.go b/protocol/goai/goai_parameter.go index 082bd60e4..d1126b908 100644 --- a/protocol/goai/goai_parameter.go +++ b/protocol/goai/goai_parameter.go @@ -9,6 +9,7 @@ package goai import ( "fmt" + "github.com/gogf/gf/v2/container/gset" "github.com/gogf/gf/v2/errors/gcode" "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/internal/json" @@ -81,10 +82,6 @@ func (oai *OpenApiV3) newParameterRefWithStructMethod(field gstructs.Field, path parameter.Required = true case ParameterInCookie, ParameterInHeader, ParameterInQuery: - // Check validation tag. - if validateTagValue := field.Tag(TagNameValidate); gstr.ContainsI(validateTagValue, `required`) { - parameter.Required = true - } default: return nil, gerror.NewCodef(gcode.CodeInvalidParameter, `invalid tag value "%s" for In`, parameter.In) @@ -96,6 +93,13 @@ func (oai *OpenApiV3) newParameterRefWithStructMethod(field gstructs.Field, path } parameter.Schema = schemaRef + // Required check. + if parameter.Schema.Value.Pattern != "" { + if gset.NewStrSetFrom(gstr.Split(parameter.Schema.Value.Pattern, "|")).Contains(patternKeyForRequired) { + parameter.Required = true + } + } + return &ParameterRef{ Ref: "", Value: parameter, diff --git a/protocol/goai/goai_requestbody.go b/protocol/goai/goai_requestbody.go index 1676623fc..d6311a0c8 100644 --- a/protocol/goai/goai_requestbody.go +++ b/protocol/goai/goai_requestbody.go @@ -97,7 +97,6 @@ func (oai *OpenApiV3) getRequestSchemaRef(in getRequestSchemaRefInput) (*SchemaR } } } - return &SchemaRef{ Value: schema, }, nil diff --git a/protocol/goai/goai_shema.go b/protocol/goai/goai_shema.go index 627c3e332..a3989502c 100644 --- a/protocol/goai/goai_shema.go +++ b/protocol/goai/goai_shema.go @@ -10,6 +10,7 @@ import ( "reflect" "github.com/gogf/gf/v2/container/gmap" + "github.com/gogf/gf/v2/container/gset" "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/internal/utils" "github.com/gogf/gf/v2/os/gstructs" @@ -154,6 +155,16 @@ func (oai *OpenApiV3) structToSchema(object interface{}) (*Schema, error) { } schema.Properties.Set(fieldName, *schemaRef) } + + schema.Properties.Iterator(func(key string, ref SchemaRef) bool { + if ref.Value != nil && ref.Value.Pattern != "" { + validationRuleSet := gset.NewStrSetFrom(gstr.Split(ref.Value.Pattern, "|")) + if validationRuleSet.Contains(patternKeyForRequired) { + schema.Required = append(schema.Required, key) + } + } + return true + }) return schema, nil } @@ -165,8 +176,16 @@ func (oai *OpenApiV3) tagMapToSchema(tagMap map[string]string, schema *Schema) e // Validation info to OpenAPI schema pattern. for _, tag := range gvalid.GetTags() { if validationTagValue, ok := tagMap[tag]; ok { - _, validationRule, _ := gvalid.ParseTagValue(validationTagValue) - schema.Pattern = validationRule + _, validationRules, _ := gvalid.ParseTagValue(validationTagValue) + schema.Pattern = validationRules + // Enum checks. + if len(schema.Enum) == 0 { + for _, rule := range gstr.SplitAndTrim(validationRules, "|") { + if gstr.HasPrefix(rule, patternKeyForIn) { + schema.Enum = gconv.Interfaces(gstr.SplitAndTrim(rule[len(patternKeyForIn):], ",")) + } + } + } break } } diff --git a/protocol/goai/goai_z_unit_test.go b/protocol/goai/goai_z_unit_test.go index 7c734f74a..f18a77761 100644 --- a/protocol/goai/goai_z_unit_test.go +++ b/protocol/goai/goai_z_unit_test.go @@ -748,3 +748,54 @@ func TestOpenApiV3_HtmlResponseWithCommonResponse(t *testing.T) { t.Assert(oai.Components.Schemas.Get(`github.com.gogf.gf.v2.protocol.goai_test.Res`).Value.Type, goai.TypeString) }) } + +func Test_Required_In_Schema(t *testing.T) { + type CommonReq struct { + AppId int64 `json:"appId" v:"required" in:"cookie" description:"应用Id"` + ResourceId string `json:"resourceId" in:"query" description:"资源Id"` + } + type SetSpecInfo struct { + StorageType string `v:"required|in:CLOUD_PREMIUM,CLOUD_SSD,CLOUD_HSSD" description:"StorageType"` + Shards int32 `description:"shards 分片数"` + Params []string `description:"默认参数(json 串-ClickHouseParams)"` + } + type CreateResourceReq struct { + CommonReq + gmeta.Meta `path:"/CreateResourceReq" method:"POST" tags:"default"` + Name string `description:"实例名称"` + Product string `description:"业务类型"` + Region string `v:"required|min:1" description:"区域"` + SetMap map[string]*SetSpecInfo `v:"required|min:1" description:"配置Map"` + SetSlice []SetSpecInfo `v:"required|min:1" description:"配置Slice"` + } + + gtest.C(t, func(t *gtest.T) { + var ( + err error + oai = goai.New() + req = new(CreateResourceReq) + ) + err = oai.Add(goai.AddInput{ + Object: req, + }) + t.AssertNil(err) + var ( + schemaKey1 = `github.com.gogf.gf.v2.protocol.goai_test.CreateResourceReq` + schemaKey2 = `github.com.gogf.gf.v2.protocol.goai_test.SetSpecInfo` + ) + t.Assert(oai.Components.Schemas.Map()[schemaKey1].Value.Required, g.Slice{ + "appId", + "Region", + "SetMap", + "SetSlice", + }) + t.Assert(oai.Components.Schemas.Map()[schemaKey2].Value.Required, g.Slice{ + "StorageType", + }) + t.Assert(oai.Components.Schemas.Map()[schemaKey2].Value.Properties.Map()["StorageType"].Value.Enum, g.Slice{ + "CLOUD_PREMIUM", + "CLOUD_SSD", + "CLOUD_HSSD", + }) + }) +} From 9cf6124c4c21d07182ad4314a3cc13de2d7888c8 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 7 Mar 2022 21:09:02 +0800 Subject: [PATCH 049/136] improve package goai --- protocol/goai/goai_parameter.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/protocol/goai/goai_parameter.go b/protocol/goai/goai_parameter.go index d1126b908..f3f219646 100644 --- a/protocol/goai/goai_parameter.go +++ b/protocol/goai/goai_parameter.go @@ -94,7 +94,7 @@ func (oai *OpenApiV3) newParameterRefWithStructMethod(field gstructs.Field, path parameter.Schema = schemaRef // Required check. - if parameter.Schema.Value.Pattern != "" { + if parameter.Schema != nil && parameter.Schema.Value.Pattern != "" { if gset.NewStrSetFrom(gstr.Split(parameter.Schema.Value.Pattern, "|")).Contains(patternKeyForRequired) { parameter.Required = true } From ade9ae3c0b5b8cea161d557139ab6cc1bca30fbf Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 7 Mar 2022 21:29:37 +0800 Subject: [PATCH 050/136] improve package goai --- protocol/goai/goai_parameter.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/protocol/goai/goai_parameter.go b/protocol/goai/goai_parameter.go index f3f219646..faed0d41c 100644 --- a/protocol/goai/goai_parameter.go +++ b/protocol/goai/goai_parameter.go @@ -94,7 +94,7 @@ func (oai *OpenApiV3) newParameterRefWithStructMethod(field gstructs.Field, path parameter.Schema = schemaRef // Required check. - if parameter.Schema != nil && parameter.Schema.Value.Pattern != "" { + if parameter.Schema.Value != nil && parameter.Schema.Value.Pattern != "" { if gset.NewStrSetFrom(gstr.Split(parameter.Schema.Value.Pattern, "|")).Contains(patternKeyForRequired) { parameter.Required = true } From e09704a40825331dd612b49afef7e20b5ca6d234 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 7 Mar 2022 22:10:34 +0800 Subject: [PATCH 051/136] example updates for package gmap --- container/gmap/gmap_z_example_list_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/container/gmap/gmap_z_example_list_test.go b/container/gmap/gmap_z_example_list_test.go index 0fab8cd80..8e935fc52 100644 --- a/container/gmap/gmap_z_example_list_test.go +++ b/container/gmap/gmap_z_example_list_test.go @@ -196,7 +196,7 @@ func ExampleListMap_Sets() { m.Sets(addMap) fmt.Println(m) - // Output: + // May Output: // {"key1":"val1","key2":"val2","key3":"val3"} } From 10ed04cdb8d06d9bcd8f3a4bf12d5daac083da8b Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 09:49:33 +0800 Subject: [PATCH 052/136] example updates for package gmap --- container/gmap/gmap_z_unit_list_map_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/container/gmap/gmap_z_unit_list_map_test.go b/container/gmap/gmap_z_unit_list_map_test.go index 0605e20a1..34851f693 100644 --- a/container/gmap/gmap_z_unit_list_map_test.go +++ b/container/gmap/gmap_z_unit_list_map_test.go @@ -186,7 +186,6 @@ func Test_ListMap_Json(t *testing.T) { gtest.C(t, func(t *gtest.T) { data := g.MapAnyAny{ "k1": "v1", - "k2": "v2", } m1 := gmap.NewListMapFrom(data) b1, err1 := json.Marshal(m1) From 0b3cd7b7aeba0937aa8cd85c0404f2578a1a070a Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 11:50:23 +0800 Subject: [PATCH 053/136] improve handler response for ghttp.Server --- .../ghttp_middleware_handler_response.go | 38 +++++++++++-------- ...ttp_z_unit_feature_openapi_swagger_test.go | 2 +- ...it_feature_router_handler_extended_test.go | 10 ++--- 3 files changed, 28 insertions(+), 22 deletions(-) diff --git a/net/ghttp/ghttp_middleware_handler_response.go b/net/ghttp/ghttp_middleware_handler_response.go index 5887af54e..e4b548da3 100644 --- a/net/ghttp/ghttp_middleware_handler_response.go +++ b/net/ghttp/ghttp_middleware_handler_response.go @@ -7,6 +7,8 @@ package ghttp import ( + "net/http" + "github.com/gogf/gf/v2/errors/gcode" "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/internal/intlog" @@ -28,29 +30,33 @@ func MiddlewareHandlerResponse(r *Request) { } var ( - ctx = r.Context() - err = r.GetError() - res = r.GetHandlerResponse() - internalErr error + msg string + ctx = r.Context() + err = r.GetError() + res = r.GetHandlerResponse() + code = gerror.Code(err) ) if err != nil { - code := gerror.Code(err) if code == gcode.CodeNil { code = gcode.CodeInternalError } - internalErr = r.Response.WriteJson(DefaultHandlerResponse{ - Code: code.Code(), - Message: err.Error(), - Data: nil, - }) - if internalErr != nil { - intlog.Errorf(ctx, `%+v`, internalErr) + msg = err.Error() + } else if r.Response.Status > 0 && r.Response.Status != http.StatusOK { + msg = http.StatusText(r.Response.Status) + switch r.Response.Status { + case http.StatusNotFound: + code = gcode.CodeNotFound + case http.StatusForbidden: + code = gcode.CodeNotAuthorized + default: + code = gcode.CodeUnknown } - return + } else { + code = gcode.CodeOK } - internalErr = r.Response.WriteJson(DefaultHandlerResponse{ - Code: gcode.CodeOK.Code(), - Message: "", + internalErr := r.Response.WriteJson(DefaultHandlerResponse{ + Code: code.Code(), + Message: msg, Data: res, }) if internalErr != nil { diff --git a/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go b/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go index a1ff87c45..d271cd9bd 100644 --- a/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go +++ b/net/ghttp/ghttp_z_unit_feature_openapi_swagger_test.go @@ -60,7 +60,7 @@ func Test_OpenApi_Swagger(t *testing.T) { c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) t.Assert(c.GetContent(ctx, "/test?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Age":18,"Name":"john"}}`) - t.Assert(c.GetContent(ctx, "/test/error"), `{"code":50,"message":"error","data":null}`) + t.Assert(c.GetContent(ctx, "/test/error"), `{"code":50,"message":"error","data":{"Id":1,"Age":0,"Name":""}}`) t.Assert(gstr.Contains(c.GetContent(ctx, "/swagger/"), `API Reference`), true) t.Assert(gstr.Contains(c.GetContent(ctx, "/api.json"), `/test/error`), true) diff --git a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go index a3aec2932..2b9d52f6d 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go @@ -56,7 +56,7 @@ func Test_Router_Handler_Extended_Handler_WithObject(t *testing.T) { client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) t.Assert(client.GetContent(ctx, "/test?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Age":18,"Name":"john"}}`) - t.Assert(client.GetContent(ctx, "/test/error"), `{"code":50,"message":"error","data":null}`) + t.Assert(client.GetContent(ctx, "/test/error"), `{"code":50,"message":"error","data":{"Id":1,"Age":0,"Name":""}}`) }) } @@ -146,10 +146,10 @@ func Test_Router_Handler_Extended_Handler_WithObjectAndMeta(t *testing.T) { client := g.Client() client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) - t.Assert(client.GetContent(ctx, "/"), `{"code":0,"message":"","data":null}`) + t.Assert(client.GetContent(ctx, "/"), `{"code":65,"message":"Not Found","data":null}`) t.Assert(client.GetContent(ctx, "/custom-test1?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Age":18}}`) t.Assert(client.GetContent(ctx, "/custom-test2?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Name":"john"}}`) - t.Assert(client.PostContent(ctx, "/custom-test2?age=18&name=john"), `{"code":0,"message":"","data":null}`) + t.Assert(client.PostContent(ctx, "/custom-test2?age=18&name=john"), `{"code":65,"message":"Not Found","data":null}`) }) } @@ -177,10 +177,10 @@ func Test_Router_Handler_Extended_Handler_Group_Bind(t *testing.T) { client := g.Client() client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) - t.Assert(client.GetContent(ctx, "/"), `{"code":0,"message":"","data":null}`) + t.Assert(client.GetContent(ctx, "/"), `{"code":65,"message":"Not Found","data":null}`) t.Assert(client.GetContent(ctx, "/api/v1/custom-test1?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Age":18}}`) t.Assert(client.GetContent(ctx, "/api/v1/custom-test2?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Name":"john"}}`) - t.Assert(client.PostContent(ctx, "/api/v1/custom-test2?age=18&name=john"), `{"code":0,"message":"","data":null}`) + t.Assert(client.PostContent(ctx, "/api/v1/custom-test2?age=18&name=john"), `{"code":65,"message":"Not Found","data":null}`) t.Assert(client.GetContent(ctx, "/api/v1/custom-test3?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Age":18}}`) t.Assert(client.GetContent(ctx, "/api/v1/custom-test4?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Name":"john"}}`) From ab36bb8842b74cc5a7f9351eaae336aae5a5be25 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 20:12:48 +0800 Subject: [PATCH 054/136] version updates --- version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.go b/version.go index bca0c3b58..045fc0ac1 100644 --- a/version.go +++ b/version.go @@ -1,4 +1,4 @@ package gf -const VERSION = "v2.0.0-rc3" +const VERSION = "v2.0.0" const AUTHORS = "john" From d0a8e60ace88825b0af36d4d6444a9c45713209b Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 20:14:38 +0800 Subject: [PATCH 055/136] improve example for package gmap --- container/gmap/gmap_z_example_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/container/gmap/gmap_z_example_test.go b/container/gmap/gmap_z_example_test.go index 4ef5fe3b4..416725580 100644 --- a/container/gmap/gmap_z_example_test.go +++ b/container/gmap/gmap_z_example_test.go @@ -8,6 +8,7 @@ package gmap_test import ( "fmt" + "github.com/gogf/gf/v2/util/gutil" "github.com/gogf/gf/v2/container/gmap" @@ -305,7 +306,7 @@ func ExampleNewTreeMapFrom() { n := gmap.NewListMapFrom(m.Map(), true) fmt.Println(n.Map()) - // Output: + // May Output: // map[key1:var1 key2:var2] // map[key1:var1 key2:var2] } From c2fb7ada0afe7f306274fbf94464cb5eb945ccb3 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 20:25:34 +0800 Subject: [PATCH 056/136] improve example for package gmap --- container/gmap/gmap_z_example_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/container/gmap/gmap_z_example_test.go b/container/gmap/gmap_z_example_test.go index 416725580..d7f76c1b9 100644 --- a/container/gmap/gmap_z_example_test.go +++ b/container/gmap/gmap_z_example_test.go @@ -278,7 +278,7 @@ func ExampleNewListMapFrom() { n := gmap.NewListMapFrom(m.Map(), true) fmt.Println(n) - // Output: + // May Output: // {"key1":"var1","key2":"var2"} // {"key1":"var1","key2":"var2"} } @@ -291,7 +291,7 @@ func ExampleNewTreeMap() { fmt.Println(m.Map()) - // Output: + // May Output: // map[key1:var1 key2:var2] } From b0cf501782ecbd532fc60bf07e131b3e723658e2 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 20:28:18 +0800 Subject: [PATCH 057/136] ci updates --- .github/workflows/cli.yml | 30 ++---------------------------- 1 file changed, 2 insertions(+), 28 deletions(-) diff --git a/.github/workflows/cli.yml b/.github/workflows/cli.yml index 5019ddc0b..49c660a28 100644 --- a/.github/workflows/cli.yml +++ b/.github/workflows/cli.yml @@ -9,7 +9,6 @@ on: env: TZ: Asia/Shanghai - jobs: build: name: Build And Release @@ -30,37 +29,12 @@ jobs: GOOS=linux GOARCH=amd64 go build main.go chmod +x main ./main install -y - - # gf build + - name: Build CLI Binary For All Platform run: | cd cmd/gf gf build main.go -n gf -a all -s all - - # 处理gf-cli批量编译后的文件结构 - - name: Move Files Before Upx - run: | - cd cmd/gf/bin - for OS in *;do for FILE in $OS/*;\ - do if [[ ${OS} =~ 'windows' ]];\ - then rm -rf noupx && mkdir noupx && mv $FILE noupx/gf_$OS.exe && rm -rf $OS;\ - else mv $FILE gf_$OS && rm -rf $OS;\ - fi;done;done - # UPX 加壳所有文件 - - name: Upx All Binary - uses: gacts/upx@master - with: - dir: 'cmd/gf/bin' - upx_args: '-9' - - # 移动未UPX的windows程序到上传bin目录下 - - name: Move Files After Upx - run: | - cd cmd/gf/bin - mv noupx/* ./ && rm -rf noupx - ls -l - - name: Create Github Release id: create_release uses: actions/create-release@v1 @@ -78,4 +52,4 @@ jobs: env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: - asset_paths: '["cmd/gf/bin/gf_*"]' + asset_paths: '["cmd/gf/temp/gf_*"]' From ec01693773593bda61709c3d2c8de253eaf815b3 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 21:04:48 +0800 Subject: [PATCH 058/136] ci updates --- .github/workflows/cli.yml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.github/workflows/cli.yml b/.github/workflows/cli.yml index 49c660a28..1ef0876c1 100644 --- a/.github/workflows/cli.yml +++ b/.github/workflows/cli.yml @@ -9,6 +9,7 @@ on: env: TZ: Asia/Shanghai + jobs: build: name: Build And Release @@ -35,6 +36,15 @@ jobs: cd cmd/gf gf build main.go -n gf -a all -s all + - name: Move Files Before Release + run: | + cd cmd/gf/temp + for OS in *;do for FILE in $OS/*;\ + do if [[ ${OS} =~ 'windows' ]];\ + then rm -rf noupx && mkdir noupx && mv $FILE noupx/gf_$OS.exe && rm -rf $OS;\ + else mv $FILE gf_$OS && rm -rf $OS;\ + fi;done;done + - name: Create Github Release id: create_release uses: actions/create-release@v1 From 6afc725b6149f10f8dab35dfb16c46de2ada9311 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 21:22:01 +0800 Subject: [PATCH 059/136] ci updates --- .github/workflows/cli.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/cli.yml b/.github/workflows/cli.yml index 1ef0876c1..cd0266155 100644 --- a/.github/workflows/cli.yml +++ b/.github/workflows/cli.yml @@ -36,7 +36,7 @@ jobs: cd cmd/gf gf build main.go -n gf -a all -s all - - name: Move Files Before Release + - name: Move Files Before Upx run: | cd cmd/gf/temp for OS in *;do for FILE in $OS/*;\ @@ -45,6 +45,12 @@ jobs: else mv $FILE gf_$OS && rm -rf $OS;\ fi;done;done + - name: Move Files After Upx + run: | + cd cmd/gf/temp + mv noupx/* ./ && rm -rf noupx + ls -l + - name: Create Github Release id: create_release uses: actions/create-release@v1 From aa294ea5df3b86dd8d45dcbf8f3f8b3b5176acf8 Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 21:27:14 +0800 Subject: [PATCH 060/136] ci updates --- .github/workflows/cli.yml | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/.github/workflows/cli.yml b/.github/workflows/cli.yml index cd0266155..9e081bdaf 100644 --- a/.github/workflows/cli.yml +++ b/.github/workflows/cli.yml @@ -36,20 +36,12 @@ jobs: cd cmd/gf gf build main.go -n gf -a all -s all - - name: Move Files Before Upx + - name: Move Files Before Release run: | cd cmd/gf/temp for OS in *;do for FILE in $OS/*;\ - do if [[ ${OS} =~ 'windows' ]];\ - then rm -rf noupx && mkdir noupx && mv $FILE noupx/gf_$OS.exe && rm -rf $OS;\ - else mv $FILE gf_$OS && rm -rf $OS;\ - fi;done;done - - - name: Move Files After Upx - run: | - cd cmd/gf/temp - mv noupx/* ./ && rm -rf noupx - ls -l + do mv $FILE gf_$OS && rm -rf $OS;\ + done;done - name: Create Github Release id: create_release From 8f326dcac5548d85d465a135b6fa74af70a2be1c Mon Sep 17 00:00:00 2001 From: John Guo Date: Tue, 8 Mar 2022 22:51:56 +0800 Subject: [PATCH 061/136] project template update --- cmd/gf/internal/packed/template-mono.go | 2 +- cmd/gf/internal/packed/template-single.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/gf/internal/packed/template-mono.go b/cmd/gf/internal/packed/template-mono.go index b21df6ddc..ddf9d3d5e 100644 --- a/cmd/gf/internal/packed/template-mono.go +++ b/cmd/gf/internal/packed/template-mono.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("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"); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } diff --git a/cmd/gf/internal/packed/template-single.go b/cmd/gf/internal/packed/template-single.go index 152642675..16fce76ee 100644 --- a/cmd/gf/internal/packed/template-single.go +++ b/cmd/gf/internal/packed/template-single.go @@ -3,7 +3,7 @@ package packed import "github.com/gogf/gf/v2/os/gres" func init() { - if err := gres.Add("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"); err != nil { + if err := gres.Add("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"); err != nil { panic("add binary content to resource manager failed: " + err.Error()) } } From 4f95d0a07acecebab2ae645913272e2890f03721 Mon Sep 17 00:00:00 2001 From: bert Date: Wed, 9 Mar 2022 10:53:28 +0800 Subject: [PATCH 062/136] Repeat 'len(s)'. --- internal/utils/utils_str.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/utils/utils_str.go b/internal/utils/utils_str.go index 358d7d685..50da1a6f3 100644 --- a/internal/utils/utils_str.go +++ b/internal/utils/utils_str.go @@ -57,13 +57,13 @@ func IsNumeric(s string) bool { if length == 0 { return false } - for i := 0; i < len(s); i++ { + for i := 0; i < length; i++ { if s[i] == '-' && i == 0 { continue } if s[i] == '.' { dotCount++ - if i > 0 && i < len(s)-1 { + if i > 0 && i < length-1 { continue } else { return false From 2302f88847d3cefd32c6ec9df7326bd78a37a580 Mon Sep 17 00:00:00 2001 From: star liu Date: Wed, 9 Mar 2022 11:27:52 +0800 Subject: [PATCH 063/136] [fix] gf cli build missing suffix --- .github/workflows/cli.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/cli.yml b/.github/workflows/cli.yml index 9e081bdaf..a7d483516 100644 --- a/.github/workflows/cli.yml +++ b/.github/workflows/cli.yml @@ -40,8 +40,10 @@ jobs: run: | cd cmd/gf/temp for OS in *;do for FILE in $OS/*;\ - do mv $FILE gf_$OS && rm -rf $OS;\ - done;done + do if [[ ${OS} =~ 'windows' ]];\ + then mv $FILE gf_$OS.exe && rm -rf $OS;\ + else mv $FILE gf_$OS && rm -rf $OS;\ + fi;done;done - name: Create Github Release id: create_release From 2510e0412d8326aae6e8ad548ba22c4a392b2f39 Mon Sep 17 00:00:00 2001 From: yxh Date: Wed, 9 Mar 2022 17:21:02 +0800 Subject: [PATCH 064/136] [fix bug] Fix redis cache adapter GetOrSetFunc, GetOrSetFuncLock method bug and add unit test --- os/gcache/gcache_adapter_redis.go | 4 +-- ...cache_z_unit_feature_adapter_redis_test.go | 33 +++++++++++++++++++ 2 files changed, 35 insertions(+), 2 deletions(-) diff --git a/os/gcache/gcache_adapter_redis.go b/os/gcache/gcache_adapter_redis.go index 2ee71388a..30b0b56cd 100644 --- a/os/gcache/gcache_adapter_redis.go +++ b/os/gcache/gcache_adapter_redis.go @@ -189,7 +189,7 @@ func (c *AdapterRedis) GetOrSet(ctx context.Context, key interface{}, value inte if err != nil { return nil, err } - if result == nil { + if result.IsNil() { return gvar.New(value), c.Set(ctx, key, value, duration) } return @@ -207,7 +207,7 @@ func (c *AdapterRedis) GetOrSetFunc(ctx context.Context, key interface{}, f Func if err != nil { return nil, err } - if v == nil { + if v.IsNil() { value, err := f(ctx) if err != nil { return nil, err diff --git a/os/gcache/gcache_z_unit_feature_adapter_redis_test.go b/os/gcache/gcache_z_unit_feature_adapter_redis_test.go index b88500751..0ee7bb314 100644 --- a/os/gcache/gcache_z_unit_feature_adapter_redis_test.go +++ b/os/gcache/gcache_z_unit_feature_adapter_redis_test.go @@ -7,6 +7,7 @@ package gcache_test import ( + "context" "testing" "time" @@ -177,3 +178,35 @@ func Test_AdapterRedis_SetIfNotExist(t *testing.T) { t.Assert(d <= time.Second, true) }) } + +func Test_AdapterRedis_GetOrSetFunc(t *testing.T) { + defer cacheRedis.Clear(ctx) + gtest.C(t, func(t *gtest.T) { + var ( + key = "key" + value1 = "valueFunc" + ) + v, err := cacheRedis.GetOrSetFunc(ctx, key, func(ctx context.Context) (value interface{}, err error) { + value = value1 + return + }, 0) + t.AssertNil(err) + t.Assert(v, value1) + }) +} + +func Test_AdapterRedis_GetOrSetFuncLock(t *testing.T) { + defer cacheRedis.Clear(ctx) + gtest.C(t, func(t *gtest.T) { + var ( + key = "key" + value1 = "valueFuncLock" + ) + v, err := cacheRedis.GetOrSetFuncLock(ctx, key, func(ctx context.Context) (value interface{}, err error) { + value = value1 + return + }, time.Second*60) + t.AssertNil(err) + t.Assert(v, value1) + }) +} From 920dbbef5e4baeefc1cb26ce5ddbb96b8b48161b Mon Sep 17 00:00:00 2001 From: houseme Date: Wed, 9 Mar 2022 17:42:56 +0800 Subject: [PATCH 065/136] fix: server access logs contain the protocol used between the server and the load balancer, but not the protocol used between the client and the load balancer --- net/ghttp/ghttp_request.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_request.go b/net/ghttp/ghttp_request.go index be5935f41..5c546d164 100644 --- a/net/ghttp/ghttp_request.go +++ b/net/ghttp/ghttp_request.go @@ -225,7 +225,8 @@ func (r *Request) GetRemoteIp() string { // GetUrl returns current URL of this request. func (r *Request) GetUrl() string { scheme := "http" - if r.TLS != nil { + proto := r.Header.Get("X-Forwarded-Proto") + if r.TLS != nil || (proto != "" && strings.ToLower(proto) == "https") { scheme = "https" } return fmt.Sprintf(`%s://%s%s`, scheme, r.Host, r.URL.String()) From 553793021081a1c8dbe0520d59d5258929f38bb2 Mon Sep 17 00:00:00 2001 From: houseme Date: Wed, 9 Mar 2022 18:30:32 +0800 Subject: [PATCH 066/136] fix --- net/ghttp/ghttp_server_swagger.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_server_swagger.go b/net/ghttp/ghttp_server_swagger.go index 846993c9a..5071a72b6 100644 --- a/net/ghttp/ghttp_server_swagger.go +++ b/net/ghttp/ghttp_server_swagger.go @@ -7,6 +7,8 @@ package ghttp import ( + "fmt" + "github.com/gogf/gf/v2/text/gstr" ) @@ -45,7 +47,7 @@ func (s *Server) swaggerUI(r *Request) { if r.StaticFile != nil && r.StaticFile.File != nil && r.StaticFile.IsDir { content := gstr.ReplaceByMap(swaggerUITemplate, map[string]string{ swaggerUIDocURLPlaceHolder: s.config.OpenApiPath, - swaggerUIDocNamePlaceHolder: gstr.TrimRight(r.GetUrl(), "/") + "/" + swaggerUIDocName, + swaggerUIDocNamePlaceHolder: gstr.TrimRight(fmt.Sprintf(`//%s%s`, r.Host, r.URL.String()), "/") + "/" + swaggerUIDocName, }) r.Response.Write(content) r.ExitAll() From f6054ab37fa3bebac98556ff29d0ff50efa57d1b Mon Sep 17 00:00:00 2001 From: houseme Date: Wed, 9 Mar 2022 18:32:13 +0800 Subject: [PATCH 067/136] improve code --- net/ghttp/ghttp_request.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/net/ghttp/ghttp_request.go b/net/ghttp/ghttp_request.go index 5c546d164..cba973756 100644 --- a/net/ghttp/ghttp_request.go +++ b/net/ghttp/ghttp_request.go @@ -224,8 +224,11 @@ func (r *Request) GetRemoteIp() string { // GetUrl returns current URL of this request. func (r *Request) GetUrl() string { - scheme := "http" - proto := r.Header.Get("X-Forwarded-Proto") + var ( + scheme = "http" + proto = r.Header.Get("X-Forwarded-Proto") + ) + if r.TLS != nil || (proto != "" && strings.ToLower(proto) == "https") { scheme = "https" } From 1625fc6f7eab88452db84da916bd566de1b4d97a Mon Sep 17 00:00:00 2001 From: John Guo Date: Wed, 9 Mar 2022 21:02:08 +0800 Subject: [PATCH 068/136] improve order feature for gdb.Model --- database/gdb/gdb_model_order_group.go | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/database/gdb/gdb_model_order_group.go b/database/gdb/gdb_model_order_group.go index b19c1bf4e..3298c0456 100644 --- a/database/gdb/gdb_model_order_group.go +++ b/database/gdb/gdb_model_order_group.go @@ -7,8 +7,10 @@ package gdb import ( - "github.com/gogf/gf/v2/util/gconv" "strings" + + "github.com/gogf/gf/v2/text/gstr" + "github.com/gogf/gf/v2/util/gconv" ) // Order sets the "ORDER BY" statement for the model. @@ -16,7 +18,8 @@ import ( // Eg: // Order("id desc") // Order("id", "desc"). -// Order("id desc,name asc"). +// Order("id desc,name asc") +// Order("id desc").Order("name asc") // Order(gdb.Raw("field(id, 3,1,2)")). func (m *Model) Order(orderBy ...interface{}) *Model { if len(orderBy) == 0 { @@ -26,13 +29,14 @@ func (m *Model) Order(orderBy ...interface{}) *Model { if model.orderBy != "" { model.orderBy += "," } - for _, o := range orderBy { - if v, ok := o.(Raw); ok { + for _, v := range orderBy { + switch v.(type) { + case Raw, *Raw: model.orderBy += gconv.String(v) return model } } - model.orderBy += model.db.GetCore().QuoteString(strings.Join(gconv.SliceStr(orderBy), " ")) + model.orderBy += model.db.GetCore().QuoteString(gstr.JoinAny(orderBy, " ")) return model } From be4720373255fe74391e6287c91ea8119c1e8486 Mon Sep 17 00:00:00 2001 From: houseme Date: Wed, 9 Mar 2022 21:24:57 +0800 Subject: [PATCH 069/136] improve code --- net/ghttp/ghttp_request.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_request.go b/net/ghttp/ghttp_request.go index cba973756..725b1bb53 100644 --- a/net/ghttp/ghttp_request.go +++ b/net/ghttp/ghttp_request.go @@ -19,6 +19,7 @@ import ( "github.com/gogf/gf/v2/os/gtime" "github.com/gogf/gf/v2/os/gview" "github.com/gogf/gf/v2/text/gregex" + "github.com/gogf/gf/v2/text/gstr" "github.com/gogf/gf/v2/util/guid" ) @@ -229,7 +230,7 @@ func (r *Request) GetUrl() string { proto = r.Header.Get("X-Forwarded-Proto") ) - if r.TLS != nil || (proto != "" && strings.ToLower(proto) == "https") { + if r.TLS != nil || gstr.Equal(proto, "https") { scheme = "https" } return fmt.Sprintf(`%s://%s%s`, scheme, r.Host, r.URL.String()) From 3d5ff3b2505a7fa8ed0de268f36aad2226b9b45c Mon Sep 17 00:00:00 2001 From: houseme Date: Wed, 9 Mar 2022 21:27:02 +0800 Subject: [PATCH 070/136] fix --- net/ghttp/ghttp_server_log.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/net/ghttp/ghttp_server_log.go b/net/ghttp/ghttp_server_log.go index 7743f1f23..b27f8b6bf 100644 --- a/net/ghttp/ghttp_server_log.go +++ b/net/ghttp/ghttp_server_log.go @@ -18,8 +18,12 @@ func (s *Server) handleAccessLog(r *Request) { if !s.IsAccessLogEnabled() { return } - scheme := "http" - if r.TLS != nil { + var ( + scheme = "http" + proto = r.Header.Get("X-Forwarded-Proto") + ) + + if r.TLS != nil || gstr.Equal(proto, "https") { scheme = "https" } s.Logger().File(s.config.AccessLogPattern). From 3d6867c32155d63640eb5cfea5e1cdbc73bad3de Mon Sep 17 00:00:00 2001 From: houseme Date: Wed, 9 Mar 2022 21:29:49 +0800 Subject: [PATCH 071/136] fix --- net/ghttp/ghttp_server_log.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_server_log.go b/net/ghttp/ghttp_server_log.go index b27f8b6bf..bcf350521 100644 --- a/net/ghttp/ghttp_server_log.go +++ b/net/ghttp/ghttp_server_log.go @@ -47,9 +47,10 @@ func (s *Server) handleErrorLog(err error, r *Request) { code = gerror.Code(err) scheme = "http" codeDetail = code.Detail() + proto = r.Header.Get("X-Forwarded-Proto") codeDetailStr string ) - if r.TLS != nil { + if r.TLS != nil || gstr.Equal(proto, "https") { scheme = "https" } if codeDetail != nil { From c200177af43d87df4b39d436bb8dfff6e201b3b0 Mon Sep 17 00:00:00 2001 From: houseme Date: Wed, 9 Mar 2022 23:36:30 +0800 Subject: [PATCH 072/136] fix: js link err --- net/ghttp/ghttp_server_swagger.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/net/ghttp/ghttp_server_swagger.go b/net/ghttp/ghttp_server_swagger.go index 5071a72b6..9f67f3758 100644 --- a/net/ghttp/ghttp_server_swagger.go +++ b/net/ghttp/ghttp_server_swagger.go @@ -47,7 +47,7 @@ func (s *Server) swaggerUI(r *Request) { if r.StaticFile != nil && r.StaticFile.File != nil && r.StaticFile.IsDir { content := gstr.ReplaceByMap(swaggerUITemplate, map[string]string{ swaggerUIDocURLPlaceHolder: s.config.OpenApiPath, - swaggerUIDocNamePlaceHolder: gstr.TrimRight(fmt.Sprintf(`//%s%s`, r.Host, r.URL.String()), "/") + "/" + swaggerUIDocName, + swaggerUIDocNamePlaceHolder: gstr.TrimRight(fmt.Sprintf(`//%s%s`, r.Host, r.Server.config.SwaggerPath), "/") + "/" + swaggerUIDocName, }) r.Response.Write(content) r.ExitAll() From 213392640c9bfd4151c2f1b00aa7ebf78a784967 Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 10 Mar 2022 09:22:50 +0800 Subject: [PATCH 073/136] fix issue #1653 --- internal/utils/utils_reflect.go | 3 + .../ghttp_z_unit_feature_router_group_test.go | 21 --- ...it_feature_router_handler_extended_test.go | 40 ----- net/ghttp/ghttp_z_unit_issue_test.go | 168 ++++++++++++++++++ net/ghttp/ghttp_z_unit_test.go | 26 --- util/gvalid/gvalid_validator_check_value.go | 4 +- 6 files changed, 172 insertions(+), 90 deletions(-) create mode 100644 net/ghttp/ghttp_z_unit_issue_test.go diff --git a/internal/utils/utils_reflect.go b/internal/utils/utils_reflect.go index f8c4df94e..928ee9d43 100644 --- a/internal/utils/utils_reflect.go +++ b/internal/utils/utils_reflect.go @@ -41,6 +41,9 @@ type OriginTypeAndKindOutput struct { // OriginTypeAndKind retrieves and returns the original reflect type and kind. func OriginTypeAndKind(value interface{}) (out OriginTypeAndKindOutput) { + if value == nil { + return + } if reflectType, ok := value.(reflect.Type); ok { out.InputType = reflectType } else { diff --git a/net/ghttp/ghttp_z_unit_feature_router_group_test.go b/net/ghttp/ghttp_z_unit_feature_router_group_test.go index c006d972e..3c64c0ae8 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_group_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_group_test.go @@ -182,24 +182,3 @@ func Test_Router_Group_Map(t *testing.T) { t.Assert(c.PostContent(ctx, "/test"), "post") }) } - -// https://github.com/gogf/gf/issues/1609 -func Test_Issue1609(t *testing.T) { - s := g.Server(guid.S()) - group := s.Group("/api/get") - group.GET("/", func(r *ghttp.Request) { - r.Response.Write("get") - }) - s.SetDumpRouterMap(false) - gtest.Assert(s.Start(), nil) - defer s.Shutdown() - - time.Sleep(100 * time.Millisecond) - gtest.C(t, func(t *gtest.T) { - c := g.Client() - c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) - - t.Assert(c.GetContent(ctx, "/api/get"), "get") - t.Assert(c.PostContent(ctx, "/test"), "Not Found") - }) -} diff --git a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go index 2b9d52f6d..003227a52 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_handler_extended_test.go @@ -16,7 +16,6 @@ import ( "github.com/gogf/gf/v2/frame/g" "github.com/gogf/gf/v2/net/ghttp" "github.com/gogf/gf/v2/test/gtest" - "github.com/gogf/gf/v2/text/gstr" "github.com/gogf/gf/v2/util/guid" ) @@ -191,42 +190,3 @@ func Test_Router_Handler_Extended_Handler_Group_Bind(t *testing.T) { t.Assert(client.GetContent(ctx, "/api/v2/custom-test4?age=18&name=john"), `{"code":0,"message":"","data":{"Id":1,"Name":"john"}}`) }) } - -// https://github.com/gogf/gf/issues/1626 -func Test_Issue1626(t *testing.T) { - type TestReq struct { - Name string `v:"required"` - } - type TestRes struct { - Name string - } - s := g.Server(guid.S()) - s.Use( - ghttp.MiddlewareHandlerResponse, - func(r *ghttp.Request) { - r.Middleware.Next() - if err := r.GetError(); err != nil { - r.Response.ClearBuffer() - r.Response.Write(err.Error()) - } - }, - ) - s.BindHandler("/test", func(ctx context.Context, req *TestReq) (res *TestRes, err error) { - return &TestRes{Name: req.Name}, nil - }) - s.SetDumpRouterMap(false) - s.Start() - defer s.Shutdown() - - time.Sleep(100 * time.Millisecond) - gtest.C(t, func(t *gtest.T) { - c := g.Client() - c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) - - t.Assert(c.GetContent(ctx, "/test"), `The Name field is required`) - t.Assert( - gstr.Contains(c.GetContent(ctx, "/test?name=john"), `{"Name":"john"}`), - true, - ) - }) -} diff --git a/net/ghttp/ghttp_z_unit_issue_test.go b/net/ghttp/ghttp_z_unit_issue_test.go new file mode 100644 index 000000000..4e1bef297 --- /dev/null +++ b/net/ghttp/ghttp_z_unit_issue_test.go @@ -0,0 +1,168 @@ +// Copyright GoFrame Author(https://goframe.org). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with this file, +// You can obtain one at https://github.com/gogf/gf. + +package ghttp_test + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/gogf/gf/v2/debug/gdebug" + "github.com/gogf/gf/v2/frame/g" + "github.com/gogf/gf/v2/net/ghttp" + "github.com/gogf/gf/v2/test/gtest" + "github.com/gogf/gf/v2/text/gstr" + "github.com/gogf/gf/v2/util/guid" +) + +// https://github.com/gogf/gf/issues/1609 +func Test_Issue1609(t *testing.T) { + s := g.Server(guid.S()) + group := s.Group("/api/get") + group.GET("/", func(r *ghttp.Request) { + r.Response.Write("get") + }) + s.SetDumpRouterMap(false) + gtest.Assert(s.Start(), nil) + defer s.Shutdown() + + time.Sleep(100 * time.Millisecond) + gtest.C(t, func(t *gtest.T) { + c := g.Client() + c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) + + t.Assert(c.GetContent(ctx, "/api/get"), "get") + t.Assert(c.PostContent(ctx, "/test"), "Not Found") + }) +} + +func Test_Issue1611(t *testing.T) { + s := g.Server(guid.S()) + v := g.View(guid.S()) + content := "This is header" + gtest.AssertNil(v.SetPath(gdebug.TestDataPath("issue1611"))) + s.SetView(v) + s.BindHandler("/", func(r *ghttp.Request) { + gtest.AssertNil(r.Response.WriteTpl("index/layout.html", g.Map{ + "header": content, + })) + }) + s.SetDumpRouterMap(false) + s.Start() + defer s.Shutdown() + + time.Sleep(100 * time.Millisecond) + gtest.C(t, func(t *gtest.T) { + c := g.Client() + c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) + + t.Assert(gstr.Contains(c.GetContent(ctx, "/"), content), true) + }) +} + +// https://github.com/gogf/gf/issues/1626 +func Test_Issue1626(t *testing.T) { + type TestReq struct { + Name string `v:"required"` + } + type TestRes struct { + Name string + } + s := g.Server(guid.S()) + s.Use( + ghttp.MiddlewareHandlerResponse, + func(r *ghttp.Request) { + r.Middleware.Next() + if err := r.GetError(); err != nil { + r.Response.ClearBuffer() + r.Response.Write(err.Error()) + } + }, + ) + s.BindHandler("/test", func(ctx context.Context, req *TestReq) (res *TestRes, err error) { + return &TestRes{Name: req.Name}, nil + }) + s.SetDumpRouterMap(false) + s.Start() + defer s.Shutdown() + + time.Sleep(100 * time.Millisecond) + gtest.C(t, func(t *gtest.T) { + c := g.Client() + c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) + + t.Assert(c.GetContent(ctx, "/test"), `The Name field is required`) + t.Assert( + gstr.Contains(c.GetContent(ctx, "/test?name=john"), `{"Name":"john"}`), + true, + ) + }) +} + +type Issue1653TestReq struct { + g.Meta `path:"/test" method:"post" summary:"执行报表查询" tags:""` + UUID string `json:"uuid" v:"required#菜单唯一码不可为空" dc:""` + Limit int `json:"limit"` + Filter []g.Map `json:"filter"` + FilterMap g.Map `json:"filter_map"` +} + +type Issue1653TestRes struct { + UUID string `json:"uuid"` + FeedBack interface{} `json:"feed_back"` +} + +type cIssue1653Foo struct{} + +var Issue1653Foo = new(cIssue1653Foo) + +func (r cIssue1653Foo) PostTest(ctx context.Context, req *Issue1653TestReq) (*Issue1653TestRes, error) { + return &Issue1653TestRes{UUID: req.UUID, FeedBack: req.Filter[0]["code"]}, nil +} + +func Test_Issue1653(t *testing.T) { + s := g.Server(guid.S()) + s.Use(ghttp.MiddlewareHandlerResponse) + s.Group("/boot", func(grp *ghttp.RouterGroup) { + grp.Bind(Issue1653Foo) + }) + s.SetPort(9527) + s.SetDumpRouterMap(false) + s.Start() + defer s.Shutdown() + time.Sleep(1000 * time.Millisecond) + // g.Client()测试： + gtest.C(t, func(t *gtest.T) { + c := g.Client() + c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) + dataReq := ` +{"uuid":"28ee701c-7daf-4cdc-9a62-6d6704e6112b","limit":0,"filter": +[ +{ +"code":"P00001","constraint":"", +"created_at":"2022-03-08 04:56:15","created_by":"3ed72aba-1622-4262-a61e-83581e020763","default_value":"MonthStart()", +"expression":"AND A.DLVDAT_0>='%v'","force":false,"frequent":true,"name":"发货日期起", +"parent":"13109602-0da3-49b9-827f-2f44183ab756","read_only":false,"reference":null,"type":"date", +"updated_at":"2022-03-08 04:56:15","updated_by":"3ed72aba-1622-4262-a61e-83581e020763","updated_tick":1, +"uuid":"e6cd3268-1d75-42e0-83f9-f1f7b29976e8" +}, +{ +"code":"P00002","constraint":"","created_at":"2022-03-08 04:56:15","created_by": +"3ed72aba-1622-4262-a61e-83581e020763","default_value":"MonthEnd()","expression":"AND A.DLVDAT_0<='%v'","force":false,"frequent":true, +"name":"发货日期止","parent":"13109602-0da3-49b9-827f-2f44183ab756","read_only":false,"reference":null,"type":"date","updated_at": +"2022-03-08 04:56:15","updated_by":"3ed72aba-1622-4262-a61e-83581e020763","updated_tick":1,"uuid":"dba005b5-655e-4ac4-8b22-898aa3ad2294" +} +], +"filter_map":{"P00001":1646064000000,"P00002":1648742399999}, +"selector_template":"" +} +` + resContent := c.PostContent(ctx, "/boot/test", dataReq) + t.Assert(resContent, `{"code":0,"message":"","data":{"uuid":"28ee701c-7daf-4cdc-9a62-6d6704e6112b","feed_back":"P00001"}}`) + }) +} diff --git a/net/ghttp/ghttp_z_unit_test.go b/net/ghttp/ghttp_z_unit_test.go index ed88da876..90f9c8d53 100644 --- a/net/ghttp/ghttp_z_unit_test.go +++ b/net/ghttp/ghttp_z_unit_test.go @@ -13,12 +13,10 @@ import ( "testing" "time" - "github.com/gogf/gf/v2/debug/gdebug" "github.com/gogf/gf/v2/frame/g" "github.com/gogf/gf/v2/net/ghttp" "github.com/gogf/gf/v2/os/genv" "github.com/gogf/gf/v2/test/gtest" - "github.com/gogf/gf/v2/text/gstr" "github.com/gogf/gf/v2/util/guid" ) @@ -76,27 +74,3 @@ func Test_XUrlPath(t *testing.T) { t.Assert(c.GetContent(ctx, "/test1"), "test2") }) } - -func Test_Issue1611(t *testing.T) { - s := g.Server(guid.S()) - v := g.View(guid.S()) - content := "This is header" - gtest.AssertNil(v.SetPath(gdebug.TestDataPath("issue1611"))) - s.SetView(v) - s.BindHandler("/", func(r *ghttp.Request) { - gtest.AssertNil(r.Response.WriteTpl("index/layout.html", g.Map{ - "header": content, - })) - }) - s.SetDumpRouterMap(false) - s.Start() - defer s.Shutdown() - - time.Sleep(100 * time.Millisecond) - gtest.C(t, func(t *gtest.T) { - c := g.Client() - c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) - - t.Assert(gstr.Contains(c.GetContent(ctx, "/"), content), true) - }) -} diff --git a/util/gvalid/gvalid_validator_check_value.go b/util/gvalid/gvalid_validator_check_value.go index 6d0d46978..2a3838baa 100644 --- a/util/gvalid/gvalid_validator_check_value.go +++ b/util/gvalid/gvalid_validator_check_value.go @@ -563,9 +563,7 @@ func (v *Validator) doCheckValueRecursively(ctx context.Context, in doCheckValue } case reflect.Map: - var ( - dataMap = gconv.Map(in.Value) - ) + var dataMap = gconv.Map(in.Value) for _, item := range dataMap { originTypeAndKind := utils.OriginTypeAndKind(item) v.doCheckValueRecursively(ctx, doCheckValueRecursivelyInput{ From 12eb3ac63eb0a7773dd9a25ade711f30099da104 Mon Sep 17 00:00:00 2001 From: sunmoon <“i@liming.me”> Date: Thu, 10 Mar 2022 09:33:33 +0800 Subject: [PATCH 074/136] [fix bug] the default value of r.get is invalid --- net/ghttp/ghttp_request_param_request.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/net/ghttp/ghttp_request_param_request.go b/net/ghttp/ghttp_request_param_request.go index 8874fa79c..8f5531676 100644 --- a/net/ghttp/ghttp_request_param_request.go +++ b/net/ghttp/ghttp_request_param_request.go @@ -24,10 +24,10 @@ import ( // retrieved and overwrote in order of priority: router < query < body < form < custom. func (r *Request) GetRequest(key string, def ...interface{}) *gvar.Var { value := r.GetParam(key) - if value == nil { + if value.IsNil() { value = r.GetForm(key) } - if value == nil { + if value.IsNil() { r.parseBody() if len(r.bodyMap) > 0 { if v := r.bodyMap[key]; v != nil { @@ -35,13 +35,13 @@ func (r *Request) GetRequest(key string, def ...interface{}) *gvar.Var { } } } - if value == nil { + if value.IsNil() { value = r.GetQuery(key) } - if value == nil { + if value.IsNil() { value = r.GetRouter(key) } - if value != nil { + if value.IsNil() { return value } if len(def) > 0 { From f5693c4393730855f6daa8b0c1661dbc5dde6b44 Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 10 Mar 2022 09:48:19 +0800 Subject: [PATCH 075/136] improve package gview --- os/gview/gview_parse.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/os/gview/gview_parse.go b/os/gview/gview_parse.go index b83096349..c1ac0cad6 100644 --- a/os/gview/gview_parse.go +++ b/os/gview/gview_parse.go @@ -60,7 +60,7 @@ var ( // and returns the parsed template content. func (view *View) Parse(ctx context.Context, file string, params ...Params) (result string, err error) { var tpl interface{} - // It caches the file, folder and its content to enhance performance. + // It caches the file, folder and content to enhance performance. r := view.fileCacheMap.GetOrSetFuncLock(file, func() interface{} { var ( path string @@ -272,10 +272,9 @@ func (view *View) getTemplate(filePath, folderPath, pattern string) (tpl interfa } } - // Secondly checking the file system. - var ( - files []string - ) + // Secondly checking the file system, + // and then automatically parsing all its sub-files recursively. + var files []string files, err = gfile.ScanDir(folderPath, pattern, true) if err != nil { return nil From 2471130f593eb721e3345e0144cc5d57c4ae6d01 Mon Sep 17 00:00:00 2001 From: sunmoon <“i@liming.me”> Date: Thu, 10 Mar 2022 09:52:45 +0800 Subject: [PATCH 076/136] =?UTF-8?q?=E9=87=8D=E8=B7=91ci?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- net/ghttp/ghttp_request_param_request.go | 1 + 1 file changed, 1 insertion(+) diff --git a/net/ghttp/ghttp_request_param_request.go b/net/ghttp/ghttp_request_param_request.go index 8f5531676..c08fa0a8b 100644 --- a/net/ghttp/ghttp_request_param_request.go +++ b/net/ghttp/ghttp_request_param_request.go @@ -22,6 +22,7 @@ import ( // // Note that if there are multiple parameters with the same name, the parameters are // retrieved and overwrote in order of priority: router < query < body < form < custom. + func (r *Request) GetRequest(key string, def ...interface{}) *gvar.Var { value := r.GetParam(key) if value.IsNil() { From eca35838452c7976acf4d91179aa6f5af67f79fa Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 10 Mar 2022 11:35:23 +0800 Subject: [PATCH 077/136] fix issue #1416; add ParseOption for package gview --- os/gview/gview_parse.go | 79 ++++++++++++++++++---- os/gview/gview_z_unit_test.go | 21 +++++- os/gview/testdata/issue1416/gview copy.tpl | 1 + os/gview/testdata/issue1416/gview.tpl | 1 + 4 files changed, 89 insertions(+), 13 deletions(-) create mode 100644 os/gview/testdata/issue1416/gview copy.tpl create mode 100644 os/gview/testdata/issue1416/gview.tpl diff --git a/os/gview/gview_parse.go b/os/gview/gview_parse.go index c1ac0cad6..44ccbffca 100644 --- a/os/gview/gview_parse.go +++ b/os/gview/gview_parse.go @@ -59,9 +59,64 @@ var ( // Parse parses given template file `file` with given template variables `params` // and returns the parsed template content. func (view *View) Parse(ctx context.Context, file string, params ...Params) (result string, err error) { - var tpl interface{} + var usedParams Params + if len(params) > 0 { + usedParams = params[0] + } + return view.ParseOption(ctx, Option{ + File: file, + Content: "", + Orphan: false, + Params: usedParams, + }) +} + +// ParseDefault parses the default template file with params. +func (view *View) ParseDefault(ctx context.Context, params ...Params) (result string, err error) { + var usedParams Params + if len(params) > 0 { + usedParams = params[0] + } + return view.ParseOption(ctx, Option{ + File: view.config.DefaultFile, + Content: "", + Orphan: false, + Params: usedParams, + }) +} + +// ParseContent parses given template content `content` with template variables `params` +// and returns the parsed content in []byte. +func (view *View) ParseContent(ctx context.Context, content string, params ...Params) (string, error) { + var usedParams Params + if len(params) > 0 { + usedParams = params[0] + } + return view.ParseOption(ctx, Option{ + Content: content, + Orphan: false, + Params: usedParams, + }) +} + +// Option for template parsing. +type Option struct { + File string // Template file path in absolute or relative to searching paths. + Content string // Template content, it ignores `File` if `Content` is given. + Orphan bool // If true, the `File` is considered as a single file parsing without files recursively parsing from its folder. + Params Params // Template parameters map. +} + +// ParseOption implements template parsing using Option. +func (view *View) ParseOption(ctx context.Context, option Option) (result string, err error) { + if option.Content != "" { + return view.doParseContent(ctx, option.Content, option.Params) + } + if option.File == "" { + return "", gerror.New(`template file cannot be empty`) + } // It caches the file, folder and content to enhance performance. - r := view.fileCacheMap.GetOrSetFuncLock(file, func() interface{} { + r := view.fileCacheMap.GetOrSetFuncLock(option.File, func() interface{} { var ( path string folder string @@ -69,7 +124,7 @@ func (view *View) Parse(ctx context.Context, file string, params ...Params) (res resource *gres.File ) // Searching the absolute file path for `file`. - path, folder, resource, err = view.searchFile(ctx, file) + path, folder, resource, err = view.searchFile(ctx, option.File) if err != nil { return nil } @@ -103,7 +158,12 @@ func (view *View) Parse(ctx context.Context, file string, params ...Params) (res if item.content == "" { return "", nil } + // If it's Orphan option, it just parses the single file by ParseContent. + if option.Orphan { + return view.doParseContent(ctx, item.content, option.Params) + } // Get the template object instance for `folder`. + var tpl interface{} tpl, err = view.getTemplate(item.path, item.folder, fmt.Sprintf(`*%s`, gfile.Ext(item.path))) if err != nil { return "", err @@ -125,7 +185,7 @@ func (view *View) Parse(ctx context.Context, file string, params ...Params) (res // Note that the template variable assignment cannot change the value // of the existing `params` or view.data because both variables are pointers. // It needs to merge the values of the two maps into a new map. - variables := gutil.MapMergeCopy(params...) + variables := gutil.MapMergeCopy(option.Params) if len(view.data) > 0 { gutil.MapMerge(variables, view.data) } @@ -152,14 +212,9 @@ func (view *View) Parse(ctx context.Context, file string, params ...Params) (res return result, nil } -// ParseDefault parses the default template file with params. -func (view *View) ParseDefault(ctx context.Context, params ...Params) (result string, err error) { - return view.Parse(ctx, view.config.DefaultFile, params...) -} - -// ParseContent parses given template content `content` with template variables `params` +// doParseContent parses given template content `content` with template variables `params` // and returns the parsed content in []byte. -func (view *View) ParseContent(ctx context.Context, content string, params ...Params) (string, error) { +func (view *View) doParseContent(ctx context.Context, content string, params Params) (string, error) { // It's not necessary continuing parsing if template content is empty. if content == "" { return "", nil @@ -196,7 +251,7 @@ func (view *View) ParseContent(ctx context.Context, content string, params ...Pa // Note that the template variable assignment cannot change the value // of the existing `params` or view.data because both variables are pointers. // It needs to merge the values of the two maps into a new map. - variables := gutil.MapMergeCopy(params...) + variables := gutil.MapMergeCopy(params) if len(view.data) > 0 { gutil.MapMerge(variables, view.data) } diff --git a/os/gview/gview_z_unit_test.go b/os/gview/gview_z_unit_test.go index 8d7f31833..8a298ea96 100644 --- a/os/gview/gview_z_unit_test.go +++ b/os/gview/gview_z_unit_test.go @@ -14,6 +14,7 @@ import ( "testing" "time" + "github.com/gogf/gf/v2/debug/gdebug" "github.com/gogf/gf/v2/encoding/ghtml" "github.com/gogf/gf/v2/frame/g" "github.com/gogf/gf/v2/os/gctx" @@ -23,6 +24,7 @@ import ( "github.com/gogf/gf/v2/test/gtest" "github.com/gogf/gf/v2/text/gstr" "github.com/gogf/gf/v2/util/gconv" + "github.com/gogf/gf/v2/util/guid" ) func init() { @@ -222,7 +224,7 @@ func Test_FuncInclude(t *testing.T) { layout = `{{include "header.html" .}} {{include "main.html" .}} {{include "footer.html" .}}` - templatePath = gfile.Temp("template") + templatePath = gfile.Temp(guid.S()) ) gfile.Mkdir(templatePath) @@ -528,3 +530,20 @@ func Test_BuildInFuncDivide(t *testing.T) { t.Assert(r, `2`) }) } + +func Test_Issue1416(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + v := gview.New() + err := v.SetPath(gdebug.TestDataPath("issue1416")) + t.AssertNil(err) + r, err := v.ParseOption(context.TODO(), gview.Option{ + File: "gview.tpl", + Orphan: true, + Params: map[string]interface{}{ + "hello": "world", + }, + }) + t.AssertNil(err) + t.Assert(r, `test.tpl content, vars: world`) + }) +} diff --git a/os/gview/testdata/issue1416/gview copy.tpl b/os/gview/testdata/issue1416/gview copy.tpl new file mode 100644 index 000000000..97b8f75cc --- /dev/null +++ b/os/gview/testdata/issue1416/gview copy.tpl @@ -0,0 +1 @@ +test.tpl content, vars: {{ hello }} \ No newline at end of file diff --git a/os/gview/testdata/issue1416/gview.tpl b/os/gview/testdata/issue1416/gview.tpl new file mode 100644 index 000000000..c31b46da5 --- /dev/null +++ b/os/gview/testdata/issue1416/gview.tpl @@ -0,0 +1 @@ +test.tpl content, vars: {{.hello}} \ No newline at end of file From 546b6b1724f0d700bc16950bc41b6a243d20b89a Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 10 Mar 2022 11:36:40 +0800 Subject: [PATCH 078/136] t.Assert(err, nil) -> t.AssertNil(err) --- .../garray/garray_z_unit_normal_any_test.go | 14 ++-- .../garray/garray_z_unit_normal_int_test.go | 16 ++-- .../garray/garray_z_unit_normal_str_test.go | 16 ++-- .../garray/garray_z_unit_sorted_any_test.go | 16 ++-- .../garray/garray_z_unit_sorted_int_test.go | 16 ++-- .../garray/garray_z_unit_sorted_str_test.go | 16 ++-- container/glist/glist_z_unit_test.go | 12 +-- .../gmap/gmap_z_unit_hash_any_any_test.go | 12 +-- .../gmap/gmap_z_unit_hash_int_any_test.go | 8 +- .../gmap/gmap_z_unit_hash_int_int_test.go | 8 +- .../gmap/gmap_z_unit_hash_int_str_test.go | 8 +- .../gmap/gmap_z_unit_hash_str_any_test.go | 12 +-- .../gmap/gmap_z_unit_hash_str_int_test.go | 12 +-- .../gmap/gmap_z_unit_hash_str_str_test.go | 12 +-- container/gmap/gmap_z_unit_list_map_test.go | 12 +-- container/gmap/gmap_z_unit_tree_map_test.go | 12 +-- container/gset/gset_z_unit_any_test.go | 6 +- container/gset/gset_z_unit_int_test.go | 6 +- container/gset/gset_z_unit_str_test.go | 6 +- container/gtype/gtype_z_unit_bool_test.go | 16 ++-- container/gtype/gtype_z_unit_byte_test.go | 4 +- container/gtype/gtype_z_unit_bytes_test.go | 4 +- container/gtype/gtype_z_unit_float32_test.go | 4 +- container/gtype/gtype_z_unit_float64_test.go | 4 +- container/gtype/gtype_z_unit_int32_test.go | 4 +- container/gtype/gtype_z_unit_int64_test.go | 4 +- container/gtype/gtype_z_unit_int_test.go | 4 +- .../gtype/gtype_z_unit_interface_test.go | 4 +- container/gtype/gtype_z_unit_string_test.go | 4 +- container/gtype/gtype_z_unit_uint32_test.go | 4 +- container/gtype/gtype_z_unit_uint64_test.go | 4 +- container/gtype/gtype_z_unit_uint_test.go | 4 +- container/gvar/gvar_z_unit_basic_test.go | 8 +- container/gvar/gvar_z_unit_json_test.go | 8 +- container/gvar/gvar_z_unit_struct_test.go | 4 +- crypto/gaes/gaes_z_unit_test.go | 24 +++--- crypto/gmd5/gmd5_z_unit_test.go | 2 +- crypto/gsha1/gsha1_z_unit_test.go | 2 +- database/gdb/gdb_z_mysql_feature_with_test.go | 60 +++++++------- database/gdb/gdb_z_mysql_model_test.go | 6 +- database/gredis/gredis_z_unit_conn_test.go | 4 +- database/gredis/gredis_z_unit_test.go | 74 ++++++++--------- encoding/gbase64/gbase64_z_unit_test.go | 4 +- .../gcompress/gcompress_z_unit_gzip_test.go | 4 +- .../gcompress/gcompress_z_unit_zip_test.go | 32 ++++---- encoding/ghtml/ghtml_z_unit_test.go | 6 +- encoding/gini/gini_z_unit_test.go | 2 +- .../gjson/gjson_z_unit_feature_json_test.go | 10 +-- .../gjson/gjson_z_unit_feature_load_test.go | 34 ++++---- .../gjson/gjson_z_unit_feature_new_test.go | 2 +- .../gjson/gjson_z_unit_feature_set_test.go | 12 +-- .../gjson/gjson_z_unit_feature_struct_test.go | 24 +++--- .../gjson/gjson_z_unit_implements_test.go | 14 ++-- encoding/gjson/gjson_z_unit_test.go | 82 +++++++++---------- encoding/gxml/gxml_z_unit_test.go | 4 +- encoding/gyaml/gyaml_z_unit_test.go | 8 +- errors/gerror/gerror_z_unit_test.go | 2 +- frame/gins/gins_z_unit_config_test.go | 26 +++--- frame/gins/gins_z_unit_database_test.go | 6 +- frame/gins/gins_z_unit_redis_test.go | 12 +-- frame/gins/gins_z_unit_view_test.go | 30 +++---- i18n/gi18n/gi18n_z_unit_test.go | 8 +- net/gclient/gclient_z_unit_test.go | 18 ++-- net/ghttp/ghttp_z_unit_feature_config_test.go | 4 +- ...tp_z_unit_feature_middleware_basic_test.go | 4 +- ...ttp_z_unit_feature_middleware_cors_test.go | 16 ++-- .../ghttp_z_unit_feature_router_basic_test.go | 22 ++--- ...z_unit_feature_router_domain_basic_test.go | 48 +++++------ ..._feature_router_domain_object_rest_test.go | 6 +- ...p_z_unit_feature_router_group_rest_test.go | 8 +- ...z_unit_feature_router_object_rest1_test.go | 4 +- .../ghttp_z_unit_feature_session_test.go | 2 +- .../ghttp_z_unit_feature_template_test.go | 18 ++-- .../ghttp_z_unit_feature_websocket_test.go | 6 +- net/gtcp/gtcp_z_unit_conn_pkg_test.go | 32 ++++---- net/gtcp/gtcp_z_unit_pool_pkg_test.go | 32 ++++---- net/gtcp/gtcp_z_unit_pool_test.go | 12 +-- net/gudp/gudp_z_unit_test.go | 14 ++-- os/gcfg/gcfg_z_unit_basic_test.go | 8 +- os/gcmd/gcmd_z_unit_parser_test.go | 4 +- os/genv/genv_z_unit_test.go | 16 ++-- os/gfile/gfile_z_unit_contents_test.go | 22 ++--- os/gfile/gfile_z_unit_copy_test.go | 2 +- os/gfile/gfile_z_unit_scan_test.go | 14 ++-- os/gfile/gfile_z_unit_search_test.go | 4 +- os/gfile/gfile_z_unit_test.go | 30 +++---- os/gfile/gfile_z_unit_time_test.go | 4 +- os/gfpool/gfpool_z_unit_test.go | 52 ++++++------ os/gfsnotify/gfsnotify_z_unit_test.go | 18 ++-- os/glog/glog_z_unit_config_test.go | 6 +- os/glog/glog_z_unit_logger_chaining_test.go | 26 +++--- os/glog/glog_z_unit_logger_rotate_test.go | 14 ++-- os/glog/glog_z_unit_test.go | 2 +- os/gres/gres_z_unit_test.go | 22 ++--- ...ion_z_unit_storage_redis_hashtable_test.go | 2 +- .../gsession_z_unit_storage_redis_test.go | 4 +- os/gspath/gspath_z_unit_test.go | 6 +- os/gtime/gtime_z_unit_feature_sql_test.go | 4 +- os/gtime/gtime_z_unit_test.go | 16 ++-- os/gview/gview_z_unit_config_test.go | 12 +-- os/gview/gview_z_unit_feature_encode_test.go | 4 +- os/gview/gview_z_unit_i18n_test.go | 12 +-- os/gview/gview_z_unit_test.go | 38 ++++----- text/gregex/gregex_z_unit_test.go | 16 ++-- text/gstr/gstr_z_unit_parse_test.go | 22 ++--- util/gconv/gconv_z_unit_all_test.go | 2 +- util/gconv/gconv_z_unit_custom_type_test.go | 2 +- util/gconv/gconv_z_unit_map_test.go | 4 +- util/gconv/gconv_z_unit_maptomap_test.go | 8 +- util/gconv/gconv_z_unit_scan_test.go | 6 +- util/gconv/gconv_z_unit_slice_test.go | 2 +- ...nv_z_unit_struct_marshal_unmarshal_test.go | 4 +- util/gconv/gconv_z_unit_struct_test.go | 66 +++++++-------- util/gconv/gconv_z_unit_structs_test.go | 14 ++-- .../gvalid_z_unit_feature_checkmap_test.go | 2 +- .../gvalid_z_unit_feature_checkstruct_test.go | 14 ++-- .../gvalid_z_unit_feature_custom_rule_test.go | 8 +- .../gvalid/gvalid_z_unit_feature_rule_test.go | 2 +- 118 files changed, 779 insertions(+), 779 deletions(-) diff --git a/container/garray/garray_z_unit_normal_any_test.go b/container/garray/garray_z_unit_normal_any_test.go index d1e132174..7532fbe86 100644 --- a/container/garray/garray_z_unit_normal_any_test.go +++ b/container/garray/garray_z_unit_normal_any_test.go @@ -576,7 +576,7 @@ func TestArray_Json(t *testing.T) { var a3 garray.Array err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // value. @@ -595,7 +595,7 @@ func TestArray_Json(t *testing.T) { var a3 garray.Array err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // pointer @@ -609,11 +609,11 @@ func TestArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, data["Scores"]) }) @@ -628,11 +628,11 @@ func TestArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, data["Scores"]) }) @@ -720,7 +720,7 @@ func TestArray_UnmarshalValue(t *testing.T) { "name": "john", "array": g.Slice{1, 2, 3}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.Slice{1, 2, 3}) }) diff --git a/container/garray/garray_z_unit_normal_int_test.go b/container/garray/garray_z_unit_normal_int_test.go index e8e3b79b3..545cbfc74 100644 --- a/container/garray/garray_z_unit_normal_int_test.go +++ b/container/garray/garray_z_unit_normal_int_test.go @@ -619,7 +619,7 @@ func TestIntArray_Json(t *testing.T) { var a3 garray.IntArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // array value @@ -637,7 +637,7 @@ func TestIntArray_Json(t *testing.T) { var a3 garray.IntArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // array pointer @@ -651,11 +651,11 @@ func TestIntArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, data["Scores"]) }) @@ -670,11 +670,11 @@ func TestIntArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, data["Scores"]) }) @@ -752,7 +752,7 @@ func TestIntArray_UnmarshalValue(t *testing.T) { "name": "john", "array": []byte(`[1,2,3]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.Slice{1, 2, 3}) }) @@ -763,7 +763,7 @@ func TestIntArray_UnmarshalValue(t *testing.T) { // "name": "john", // "array": g.Slice{1, 2, 3}, // }, &v) - // t.Assert(err, nil) + // t.AssertNil(err) // t.Assert(v.Name, "john") // t.Assert(v.Array.Slice(), g.Slice{1, 2, 3}) // }) diff --git a/container/garray/garray_z_unit_normal_str_test.go b/container/garray/garray_z_unit_normal_str_test.go index d5d8bcf6e..26130cce4 100644 --- a/container/garray/garray_z_unit_normal_str_test.go +++ b/container/garray/garray_z_unit_normal_str_test.go @@ -619,7 +619,7 @@ func TestStrArray_Json(t *testing.T) { var a3 garray.StrArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // array value @@ -637,7 +637,7 @@ func TestStrArray_Json(t *testing.T) { var a3 garray.StrArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // array pointer @@ -651,11 +651,11 @@ func TestStrArray_Json(t *testing.T) { "Scores": []string{"A+", "A", "A"}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, data["Scores"]) }) @@ -670,11 +670,11 @@ func TestStrArray_Json(t *testing.T) { "Scores": []string{"A+", "A", "A"}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, data["Scores"]) }) @@ -751,7 +751,7 @@ func TestStrArray_UnmarshalValue(t *testing.T) { "name": "john", "array": []byte(`["1","2","3"]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"}) }) @@ -762,7 +762,7 @@ func TestStrArray_UnmarshalValue(t *testing.T) { "name": "john", "array": g.SliceStr{"1", "2", "3"}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"}) }) diff --git a/container/garray/garray_z_unit_sorted_any_test.go b/container/garray/garray_z_unit_sorted_any_test.go index 1513aa342..d7dad282e 100644 --- a/container/garray/garray_z_unit_sorted_any_test.go +++ b/container/garray/garray_z_unit_sorted_any_test.go @@ -661,7 +661,7 @@ func TestSortedArray_Json(t *testing.T) { var a3 garray.SortedArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) t.Assert(a3.Interfaces(), s1) }) @@ -681,7 +681,7 @@ func TestSortedArray_Json(t *testing.T) { var a3 garray.SortedArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) t.Assert(a3.Interfaces(), s1) }) @@ -696,11 +696,11 @@ func TestSortedArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.AssertNE(user.Scores, nil) t.Assert(user.Scores.Len(), 3) @@ -732,11 +732,11 @@ func TestSortedArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.AssertNE(user.Scores, nil) t.Assert(user.Scores.Len(), 3) @@ -830,7 +830,7 @@ func TestSortedArray_UnmarshalValue(t *testing.T) { "name": "john", "array": []byte(`[2,3,1]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.Slice{1, 2, 3}) }) @@ -841,7 +841,7 @@ func TestSortedArray_UnmarshalValue(t *testing.T) { "name": "john", "array": g.Slice{2, 3, 1}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.Slice{1, 2, 3}) }) diff --git a/container/garray/garray_z_unit_sorted_int_test.go b/container/garray/garray_z_unit_sorted_int_test.go index c653340c6..73a33968e 100644 --- a/container/garray/garray_z_unit_sorted_int_test.go +++ b/container/garray/garray_z_unit_sorted_int_test.go @@ -561,7 +561,7 @@ func TestSortedIntArray_Json(t *testing.T) { var a3 garray.SortedIntArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // array value @@ -580,7 +580,7 @@ func TestSortedIntArray_Json(t *testing.T) { var a3 garray.SortedIntArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) }) // array pointer @@ -594,11 +594,11 @@ func TestSortedIntArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, []int{98, 99, 100}) }) @@ -613,11 +613,11 @@ func TestSortedIntArray_Json(t *testing.T) { "Scores": []int{99, 100, 98}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, []int{98, 99, 100}) }) @@ -695,7 +695,7 @@ func TestSortedIntArray_UnmarshalValue(t *testing.T) { "name": "john", "array": []byte(`[2,3,1]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.Slice{1, 2, 3}) }) @@ -706,7 +706,7 @@ func TestSortedIntArray_UnmarshalValue(t *testing.T) { "name": "john", "array": g.Slice{2, 3, 1}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.Slice{1, 2, 3}) }) diff --git a/container/garray/garray_z_unit_sorted_str_test.go b/container/garray/garray_z_unit_sorted_str_test.go index 7625064a1..e93c1a59d 100644 --- a/container/garray/garray_z_unit_sorted_str_test.go +++ b/container/garray/garray_z_unit_sorted_str_test.go @@ -583,7 +583,7 @@ func TestSortedStrArray_Json(t *testing.T) { var a3 garray.SortedStrArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) t.Assert(a3.Interfaces(), s1) }) @@ -604,7 +604,7 @@ func TestSortedStrArray_Json(t *testing.T) { var a3 garray.SortedStrArray err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Slice(), s1) t.Assert(a3.Interfaces(), s1) }) @@ -619,11 +619,11 @@ func TestSortedStrArray_Json(t *testing.T) { "Scores": []string{"A+", "A", "A"}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, []string{"A", "A", "A+"}) }) @@ -638,11 +638,11 @@ func TestSortedStrArray_Json(t *testing.T) { "Scores": []string{"A+", "A", "A"}, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) user := new(User) err = json.UnmarshalUseNumber(b, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Name, data["Name"]) t.Assert(user.Scores, []string{"A", "A", "A+"}) }) @@ -719,7 +719,7 @@ func TestSortedStrArray_UnmarshalValue(t *testing.T) { "name": "john", "array": []byte(`["1","3","2"]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"}) }) @@ -730,7 +730,7 @@ func TestSortedStrArray_UnmarshalValue(t *testing.T) { "name": "john", "array": g.SliceStr{"1", "3", "2"}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"}) }) diff --git a/container/glist/glist_z_unit_test.go b/container/glist/glist_z_unit_test.go index edd1f7c4b..a381030fe 100644 --- a/container/glist/glist_z_unit_test.go +++ b/container/glist/glist_z_unit_test.go @@ -709,20 +709,20 @@ func TestList_Json(t *testing.T) { a := []interface{}{"a", "b", "c"} l := New() b, err := json.Marshal(a) - t.Assert(err, nil) + t.AssertNil(err) err = json.UnmarshalUseNumber(b, l) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(l.FrontAll(), a) }) gtest.C(t, func(t *gtest.T) { var l List a := []interface{}{"a", "b", "c"} b, err := json.Marshal(a) - t.Assert(err, nil) + t.AssertNil(err) err = json.UnmarshalUseNumber(b, &l) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(l.FrontAll(), a) }) } @@ -739,7 +739,7 @@ func TestList_UnmarshalValue(t *testing.T) { "name": "john", "list": []byte(`[1,2,3]`), }, &tlist) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(tlist.Name, "john") t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3}) }) @@ -750,7 +750,7 @@ func TestList_UnmarshalValue(t *testing.T) { "name": "john", "list": []interface{}{1, 2, 3}, }, &tlist) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(tlist.Name, "john") t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3}) }) diff --git a/container/gmap/gmap_z_unit_hash_any_any_test.go b/container/gmap/gmap_z_unit_hash_any_any_test.go index 7de3be37e..e30a7180e 100644 --- a/container/gmap/gmap_z_unit_hash_any_any_test.go +++ b/container/gmap/gmap_z_unit_hash_any_any_test.go @@ -253,11 +253,11 @@ func Test_AnyAnyMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(gconv.Map(data)) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.New() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -267,11 +267,11 @@ func Test_AnyAnyMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(gconv.Map(data)) - t.Assert(err, nil) + t.AssertNil(err) var m gmap.Map err = json.UnmarshalUseNumber(b, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -342,7 +342,7 @@ func TestAnyAnyMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"k1":"v1","k2":"v2"}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") @@ -358,7 +358,7 @@ func TestAnyAnyMap_UnmarshalValue(t *testing.T) { "k2": "v2", }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") diff --git a/container/gmap/gmap_z_unit_hash_int_any_test.go b/container/gmap/gmap_z_unit_hash_int_any_test.go index 13c65d2b3..480115e3b 100644 --- a/container/gmap/gmap_z_unit_hash_int_any_test.go +++ b/container/gmap/gmap_z_unit_hash_int_any_test.go @@ -242,11 +242,11 @@ func Test_IntAnyMap_Json(t *testing.T) { 2: "v2", } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewIntAnyMap() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get(1), data[1]) t.Assert(m.Get(2), data[2]) }) @@ -317,7 +317,7 @@ func TestIntAnyMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"1":"v1","2":"v2"}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get(1), "v1") @@ -333,7 +333,7 @@ func TestIntAnyMap_UnmarshalValue(t *testing.T) { 2: "v2", }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get(1), "v1") diff --git a/container/gmap/gmap_z_unit_hash_int_int_test.go b/container/gmap/gmap_z_unit_hash_int_int_test.go index d42c7f86f..f8b7dca51 100644 --- a/container/gmap/gmap_z_unit_hash_int_int_test.go +++ b/container/gmap/gmap_z_unit_hash_int_int_test.go @@ -248,11 +248,11 @@ func Test_IntIntMap_Json(t *testing.T) { 2: 20, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewIntIntMap() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get(1), data[1]) t.Assert(m.Get(2), data[2]) }) @@ -323,7 +323,7 @@ func TestIntIntMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"1":1,"2":2}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get(1), "1") @@ -339,7 +339,7 @@ func TestIntIntMap_UnmarshalValue(t *testing.T) { 2: 2, }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get(1), "1") diff --git a/container/gmap/gmap_z_unit_hash_int_str_test.go b/container/gmap/gmap_z_unit_hash_int_str_test.go index 046e2f466..b389f0fab 100644 --- a/container/gmap/gmap_z_unit_hash_int_str_test.go +++ b/container/gmap/gmap_z_unit_hash_int_str_test.go @@ -246,11 +246,11 @@ func Test_IntStrMap_Json(t *testing.T) { 2: "v2", } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewIntStrMap() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get(1), data[1]) t.Assert(m.Get(2), data[2]) }) @@ -321,7 +321,7 @@ func TestIntStrMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"1":"v1","2":"v2"}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get(1), "v1") @@ -337,7 +337,7 @@ func TestIntStrMap_UnmarshalValue(t *testing.T) { 2: "v2", }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get(1), "v1") diff --git a/container/gmap/gmap_z_unit_hash_str_any_test.go b/container/gmap/gmap_z_unit_hash_str_any_test.go index 3dd044478..3bca41980 100644 --- a/container/gmap/gmap_z_unit_hash_str_any_test.go +++ b/container/gmap/gmap_z_unit_hash_str_any_test.go @@ -240,11 +240,11 @@ func Test_StrAnyMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewStrAnyMap() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -254,11 +254,11 @@ func Test_StrAnyMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) var m gmap.StrAnyMap err = json.UnmarshalUseNumber(b, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -329,7 +329,7 @@ func TestStrAnyMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"k1":"v1","k2":"v2"}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") @@ -345,7 +345,7 @@ func TestStrAnyMap_UnmarshalValue(t *testing.T) { "k2": "v2", }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") diff --git a/container/gmap/gmap_z_unit_hash_str_int_test.go b/container/gmap/gmap_z_unit_hash_str_int_test.go index 431e4fa13..42706b185 100644 --- a/container/gmap/gmap_z_unit_hash_str_int_test.go +++ b/container/gmap/gmap_z_unit_hash_str_int_test.go @@ -244,11 +244,11 @@ func Test_StrIntMap_Json(t *testing.T) { "k2": 2, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewStrIntMap() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -258,11 +258,11 @@ func Test_StrIntMap_Json(t *testing.T) { "k2": 2, } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) var m gmap.StrIntMap err = json.UnmarshalUseNumber(b, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -333,7 +333,7 @@ func TestStrIntMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"k1":1,"k2":2}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), 1) @@ -349,7 +349,7 @@ func TestStrIntMap_UnmarshalValue(t *testing.T) { "k2": 2, }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), 1) diff --git a/container/gmap/gmap_z_unit_hash_str_str_test.go b/container/gmap/gmap_z_unit_hash_str_str_test.go index 2cfe9b4aa..ed8f385e0 100644 --- a/container/gmap/gmap_z_unit_hash_str_str_test.go +++ b/container/gmap/gmap_z_unit_hash_str_str_test.go @@ -241,11 +241,11 @@ func Test_StrStrMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewStrStrMap() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -255,11 +255,11 @@ func Test_StrStrMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(data) - t.Assert(err, nil) + t.AssertNil(err) var m gmap.StrStrMap err = json.UnmarshalUseNumber(b, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -330,7 +330,7 @@ func TestStrStrMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"k1":"v1","k2":"v2"}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") @@ -346,7 +346,7 @@ func TestStrStrMap_UnmarshalValue(t *testing.T) { "k2": "v2", }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") diff --git a/container/gmap/gmap_z_unit_list_map_test.go b/container/gmap/gmap_z_unit_list_map_test.go index 34851f693..424c83b5a 100644 --- a/container/gmap/gmap_z_unit_list_map_test.go +++ b/container/gmap/gmap_z_unit_list_map_test.go @@ -201,11 +201,11 @@ func Test_ListMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(gconv.Map(data)) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewListMap() err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -216,11 +216,11 @@ func Test_ListMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(gconv.Map(data)) - t.Assert(err, nil) + t.AssertNil(err) var m gmap.ListMap err = json.UnmarshalUseNumber(b, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -312,7 +312,7 @@ func TestListMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"1":"v1","2":"v2"}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("1"), "v1") @@ -328,7 +328,7 @@ func TestListMap_UnmarshalValue(t *testing.T) { 2: "v2", }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("1"), "v1") diff --git a/container/gmap/gmap_z_unit_tree_map_test.go b/container/gmap/gmap_z_unit_tree_map_test.go index b541d127d..fd3341e46 100644 --- a/container/gmap/gmap_z_unit_tree_map_test.go +++ b/container/gmap/gmap_z_unit_tree_map_test.go @@ -185,11 +185,11 @@ func Test_TreeMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(gconv.Map(data)) - t.Assert(err, nil) + t.AssertNil(err) m := gmap.NewTreeMap(gutil.ComparatorString) err = json.UnmarshalUseNumber(b, m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -199,11 +199,11 @@ func Test_TreeMap_Json(t *testing.T) { "k2": "v2", } b, err := json.Marshal(gconv.Map(data)) - t.Assert(err, nil) + t.AssertNil(err) var m gmap.TreeMap err = json.UnmarshalUseNumber(b, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m.Get("k1"), data["k1"]) t.Assert(m.Get("k2"), data["k2"]) }) @@ -221,7 +221,7 @@ func TestTreeMap_UnmarshalValue(t *testing.T) { "name": "john", "map": []byte(`{"k1":"v1","k2":"v2"}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") @@ -237,7 +237,7 @@ func TestTreeMap_UnmarshalValue(t *testing.T) { "k2": "v2", }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Map.Size(), 2) t.Assert(v.Map.Get("k1"), "v1") diff --git a/container/gset/gset_z_unit_any_test.go b/container/gset/gset_z_unit_any_test.go index be0c56383..f6e4835a3 100644 --- a/container/gset/gset_z_unit_any_test.go +++ b/container/gset/gset_z_unit_any_test.go @@ -336,7 +336,7 @@ func TestSet_Json(t *testing.T) { var a3 gset.Set err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Contains("a"), true) t.Assert(a3.Contains("b"), true) t.Assert(a3.Contains("c"), true) @@ -438,7 +438,7 @@ func TestSet_UnmarshalValue(t *testing.T) { "name": "john", "set": []byte(`["k1","k2","k3"]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Set.Size(), 3) t.Assert(v.Set.Contains("k1"), true) @@ -453,7 +453,7 @@ func TestSet_UnmarshalValue(t *testing.T) { "name": "john", "set": g.Slice{"k1", "k2", "k3"}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Set.Size(), 3) t.Assert(v.Set.Contains("k1"), true) diff --git a/container/gset/gset_z_unit_int_test.go b/container/gset/gset_z_unit_int_test.go index 5f7068c75..8a7086a50 100644 --- a/container/gset/gset_z_unit_int_test.go +++ b/container/gset/gset_z_unit_int_test.go @@ -368,7 +368,7 @@ func TestIntSet_Json(t *testing.T) { var a3 gset.IntSet err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a2.Contains(1), true) t.Assert(a2.Contains(2), true) t.Assert(a2.Contains(3), true) @@ -402,7 +402,7 @@ func TestIntSet_UnmarshalValue(t *testing.T) { "name": "john", "set": []byte(`[1,2,3]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Set.Size(), 3) t.Assert(v.Set.Contains(1), true) @@ -417,7 +417,7 @@ func TestIntSet_UnmarshalValue(t *testing.T) { "name": "john", "set": g.Slice{1, 2, 3}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Set.Size(), 3) t.Assert(v.Set.Contains(1), true) diff --git a/container/gset/gset_z_unit_str_test.go b/container/gset/gset_z_unit_str_test.go index eae7cd15a..ed41308da 100644 --- a/container/gset/gset_z_unit_str_test.go +++ b/container/gset/gset_z_unit_str_test.go @@ -414,7 +414,7 @@ func TestStrSet_Json(t *testing.T) { var a3 gset.StrSet err := json.UnmarshalUseNumber(b2, &a3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a3.Contains("a"), true) t.Assert(a3.Contains("b"), true) t.Assert(a3.Contains("c"), true) @@ -453,7 +453,7 @@ func TestStrSet_UnmarshalValue(t *testing.T) { "name": "john", "set": []byte(`["1","2","3"]`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Set.Size(), 3) t.Assert(v.Set.Contains("1"), true) @@ -468,7 +468,7 @@ func TestStrSet_UnmarshalValue(t *testing.T) { "name": "john", "set": g.SliceStr{"1", "2", "3"}, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Set.Size(), 3) t.Assert(v.Set.Contains("1"), true) diff --git a/container/gtype/gtype_z_unit_bool_test.go b/container/gtype/gtype_z_unit_bool_test.go index 47c31c387..e44c6b456 100644 --- a/container/gtype/gtype_z_unit_bool_test.go +++ b/container/gtype/gtype_z_unit_bool_test.go @@ -56,16 +56,16 @@ func Test_Bool_JSON(t *testing.T) { var err error i := gtype.NewBool() err = json.UnmarshalUseNumber([]byte("true"), &i) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i.Val(), true) err = json.UnmarshalUseNumber([]byte("false"), &i) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i.Val(), false) err = json.UnmarshalUseNumber([]byte("1"), &i) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i.Val(), true) err = json.UnmarshalUseNumber([]byte("0"), &i) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i.Val(), false) }) @@ -79,7 +79,7 @@ func Test_Bool_JSON(t *testing.T) { i2 := gtype.NewBool() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), i.Val()) }) gtest.C(t, func(t *gtest.T) { @@ -92,7 +92,7 @@ func Test_Bool_JSON(t *testing.T) { i2 := gtype.NewBool() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), i.Val()) }) } @@ -108,7 +108,7 @@ func Test_Bool_UnmarshalValue(t *testing.T) { "name": "john", "var": "true", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), true) }) @@ -118,7 +118,7 @@ func Test_Bool_UnmarshalValue(t *testing.T) { "name": "john", "var": "false", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), false) }) diff --git a/container/gtype/gtype_z_unit_byte_test.go b/container/gtype/gtype_z_unit_byte_test.go index b035ff0a1..d3b87ec49 100644 --- a/container/gtype/gtype_z_unit_byte_test.go +++ b/container/gtype/gtype_z_unit_byte_test.go @@ -54,7 +54,7 @@ func Test_Byte_JSON(t *testing.T) { var err error i := gtype.NewByte() err = json.UnmarshalUseNumber([]byte("49"), &i) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i.Val(), "49") }) } @@ -70,7 +70,7 @@ func Test_Byte_UnmarshalValue(t *testing.T) { "name": "john", "var": "2", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "2") }) diff --git a/container/gtype/gtype_z_unit_bytes_test.go b/container/gtype/gtype_z_unit_bytes_test.go index f6da7ab13..d919c47bf 100644 --- a/container/gtype/gtype_z_unit_bytes_test.go +++ b/container/gtype/gtype_z_unit_bytes_test.go @@ -40,7 +40,7 @@ func Test_Bytes_JSON(t *testing.T) { i2 := gtype.NewBytes() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), b) }) } @@ -56,7 +56,7 @@ func Test_Bytes_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_float32_test.go b/container/gtype/gtype_z_unit_float32_test.go index c0a081a6e..e3e6cd667 100644 --- a/container/gtype/gtype_z_unit_float32_test.go +++ b/container/gtype/gtype_z_unit_float32_test.go @@ -42,7 +42,7 @@ func Test_Float32_JSON(t *testing.T) { i2 := gtype.NewFloat32() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), v) }) } @@ -58,7 +58,7 @@ func Test_Float32_UnmarshalValue(t *testing.T) { "name": "john", "var": "123.456", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123.456") }) diff --git a/container/gtype/gtype_z_unit_float64_test.go b/container/gtype/gtype_z_unit_float64_test.go index b5bf088f8..02339cefd 100644 --- a/container/gtype/gtype_z_unit_float64_test.go +++ b/container/gtype/gtype_z_unit_float64_test.go @@ -40,7 +40,7 @@ func Test_Float64_JSON(t *testing.T) { i2 := gtype.NewFloat64() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), v) }) } @@ -56,7 +56,7 @@ func Test_Float64_UnmarshalValue(t *testing.T) { "name": "john", "var": "123.456", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123.456") }) diff --git a/container/gtype/gtype_z_unit_int32_test.go b/container/gtype/gtype_z_unit_int32_test.go index 3a13c5801..996f4d087 100644 --- a/container/gtype/gtype_z_unit_int32_test.go +++ b/container/gtype/gtype_z_unit_int32_test.go @@ -53,7 +53,7 @@ func Test_Int32_JSON(t *testing.T) { i2 := gtype.NewInt32() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), v) }) } @@ -69,7 +69,7 @@ func Test_Int32_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_int64_test.go b/container/gtype/gtype_z_unit_int64_test.go index 1c3966b5d..f3c74bced 100644 --- a/container/gtype/gtype_z_unit_int64_test.go +++ b/container/gtype/gtype_z_unit_int64_test.go @@ -52,7 +52,7 @@ func Test_Int64_JSON(t *testing.T) { i2 := gtype.NewInt64() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), i) }) } @@ -68,7 +68,7 @@ func Test_Int64_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_int_test.go b/container/gtype/gtype_z_unit_int_test.go index 30c31d9f0..39114eb59 100644 --- a/container/gtype/gtype_z_unit_int_test.go +++ b/container/gtype/gtype_z_unit_int_test.go @@ -52,7 +52,7 @@ func Test_Int_JSON(t *testing.T) { i2 := gtype.NewInt() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), v) }) } @@ -68,7 +68,7 @@ func Test_Int_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_interface_test.go b/container/gtype/gtype_z_unit_interface_test.go index c65a92601..828edf36a 100644 --- a/container/gtype/gtype_z_unit_interface_test.go +++ b/container/gtype/gtype_z_unit_interface_test.go @@ -42,7 +42,7 @@ func Test_Interface_JSON(t *testing.T) { i2 := gtype.New() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), s) }) } @@ -58,7 +58,7 @@ func Test_Interface_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_string_test.go b/container/gtype/gtype_z_unit_string_test.go index c43830126..319adf509 100644 --- a/container/gtype/gtype_z_unit_string_test.go +++ b/container/gtype/gtype_z_unit_string_test.go @@ -40,7 +40,7 @@ func Test_String_JSON(t *testing.T) { i2 := gtype.NewString() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), s) }) } @@ -56,7 +56,7 @@ func Test_String_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_uint32_test.go b/container/gtype/gtype_z_unit_uint32_test.go index 3b0a75005..6e00fc7d8 100644 --- a/container/gtype/gtype_z_unit_uint32_test.go +++ b/container/gtype/gtype_z_unit_uint32_test.go @@ -52,7 +52,7 @@ func Test_Uint32_JSON(t *testing.T) { i2 := gtype.NewUint32() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), i) }) } @@ -68,7 +68,7 @@ func Test_Uint32_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_uint64_test.go b/container/gtype/gtype_z_unit_uint64_test.go index f2285aa3d..5fe206051 100644 --- a/container/gtype/gtype_z_unit_uint64_test.go +++ b/container/gtype/gtype_z_unit_uint64_test.go @@ -56,7 +56,7 @@ func Test_Uint64_JSON(t *testing.T) { i2 := gtype.NewUint64() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), i) }) } @@ -72,7 +72,7 @@ func Test_Uint64_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gtype/gtype_z_unit_uint_test.go b/container/gtype/gtype_z_unit_uint_test.go index 4521e6d6f..56d564d72 100644 --- a/container/gtype/gtype_z_unit_uint_test.go +++ b/container/gtype/gtype_z_unit_uint_test.go @@ -51,7 +51,7 @@ func Test_Uint_JSON(t *testing.T) { i2 := gtype.NewUint() err := json.UnmarshalUseNumber(b2, &i2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(i2.Val(), i) }) } @@ -67,7 +67,7 @@ func Test_Uint_UnmarshalValue(t *testing.T) { "name": "john", "var": "123", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.Val(), "123") }) diff --git a/container/gvar/gvar_z_unit_basic_test.go b/container/gvar/gvar_z_unit_basic_test.go index a9592b81f..b6109448e 100644 --- a/container/gvar/gvar_z_unit_basic_test.go +++ b/container/gvar/gvar_z_unit_basic_test.go @@ -253,7 +253,7 @@ func Test_UnmarshalJson(t *testing.T) { "name": "john", "var": "v", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.String(), "v") }) @@ -267,7 +267,7 @@ func Test_UnmarshalJson(t *testing.T) { "name": "john", "var": "v", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.String(), "v") }) @@ -284,7 +284,7 @@ func Test_UnmarshalValue(t *testing.T) { "name": "john", "var": "v", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.String(), "v") }) @@ -298,7 +298,7 @@ func Test_UnmarshalValue(t *testing.T) { "name": "john", "var": "v", }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Var.String(), "v") }) diff --git a/container/gvar/gvar_z_unit_json_test.go b/container/gvar/gvar_z_unit_json_test.go index d5df2f8ef..29ea08006 100644 --- a/container/gvar/gvar_z_unit_json_test.go +++ b/container/gvar/gvar_z_unit_json_test.go @@ -40,10 +40,10 @@ func TestVar_Json(t *testing.T) { s := "i love gf" v := gvar.New(nil) b, err := json.Marshal(s) - t.Assert(err, nil) + t.AssertNil(err) err = json.UnmarshalUseNumber(b, v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.String(), s) }) @@ -51,10 +51,10 @@ func TestVar_Json(t *testing.T) { var v gvar.Var s := "i love gf" b, err := json.Marshal(s) - t.Assert(err, nil) + t.AssertNil(err) err = json.UnmarshalUseNumber(b, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.String(), s) }) } diff --git a/container/gvar/gvar_z_unit_struct_test.go b/container/gvar/gvar_z_unit_struct_test.go index f397acadb..7b9e12b49 100644 --- a/container/gvar/gvar_z_unit_struct_test.go +++ b/container/gvar/gvar_z_unit_struct_test.go @@ -55,7 +55,7 @@ func TestVar_Var_Attribute_Struct(t *testing.T) { "uid": gvar.New(1), "name": gvar.New("john"), }, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Uid, 1) t.Assert(user.Name, "john") }) @@ -70,7 +70,7 @@ func TestVar_Var_Attribute_Struct(t *testing.T) { "uid": gvar.New(1), "name": gvar.New("john"), }, &user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Uid, 1) t.Assert(user.Name, "john") }) diff --git a/crypto/gaes/gaes_z_unit_test.go b/crypto/gaes/gaes_z_unit_test.go index 75ca55b3c..052b39731 100644 --- a/crypto/gaes/gaes_z_unit_test.go +++ b/crypto/gaes/gaes_z_unit_test.go @@ -41,19 +41,19 @@ var ( func TestEncrypt(t *testing.T) { gtest.C(t, func(t *gtest.T) { data, err := gaes.Encrypt(content, key_16) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(data, []byte(content_16)) data, err = gaes.Encrypt(content, key_24) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(data, []byte(content_24)) data, err = gaes.Encrypt(content, key_32) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(data, []byte(content_32)) data, err = gaes.Encrypt(content, key_16, iv) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(data, []byte(content_16_iv)) data, err = gaes.Encrypt(content, key_32, iv) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(data, []byte(content_32_iv)) }) } @@ -61,23 +61,23 @@ func TestEncrypt(t *testing.T) { func TestDecrypt(t *testing.T) { gtest.C(t, func(t *gtest.T) { decrypt, err := gaes.Decrypt([]byte(content_16), key_16) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_24), key_24) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_32), key_32) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_16_iv), key_16, iv) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv) @@ -134,7 +134,7 @@ func TestEncryptCFB(t *testing.T) { gtest.C(t, func(t *gtest.T) { var padding int = 0 data, err := gaes.EncryptCFB(content, key_16, &padding, iv) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(padding, padding_size) t.Assert(data, []byte(content_16_cfb)) }) @@ -143,7 +143,7 @@ func TestEncryptCFB(t *testing.T) { func TestDecryptCFB(t *testing.T) { gtest.C(t, func(t *gtest.T) { decrypt, err := gaes.DecryptCFB([]byte(content_16_cfb), key_16, padding_size, iv) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(decrypt, content) }) } diff --git a/crypto/gmd5/gmd5_z_unit_test.go b/crypto/gmd5/gmd5_z_unit_test.go index 697371250..95292a19c 100644 --- a/crypto/gmd5/gmd5_z_unit_test.go +++ b/crypto/gmd5/gmd5_z_unit_test.go @@ -65,7 +65,7 @@ func TestEncryptFile(t *testing.T) { file, err := os.Create(path) defer os.Remove(path) defer file.Close() - t.Assert(err, nil) + t.AssertNil(err) _, _ = file.Write([]byte("Hello Go Frame")) encryptFile, _ := gmd5.EncryptFile(path) t.AssertEQ(encryptFile, result) diff --git a/crypto/gsha1/gsha1_z_unit_test.go b/crypto/gsha1/gsha1_z_unit_test.go index 881cf3516..ea90cf725 100644 --- a/crypto/gsha1/gsha1_z_unit_test.go +++ b/crypto/gsha1/gsha1_z_unit_test.go @@ -48,7 +48,7 @@ func TestEncryptFile(t *testing.T) { file, err := os.Create(path) defer os.Remove(path) defer file.Close() - t.Assert(err, nil) + t.AssertNil(err) _, _ = file.Write([]byte("Hello Go Frame")) encryptFile, _ := gsha1.EncryptFile(path) t.AssertEQ(encryptFile, result) diff --git a/database/gdb/gdb_z_mysql_feature_with_test.go b/database/gdb/gdb_z_mysql_feature_with_test.go index 243e83d76..3175cb2d9 100644 --- a/database/gdb/gdb_z_mysql_feature_with_test.go +++ b/database/gdb/gdb_z_mysql_feature_with_test.go @@ -353,20 +353,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } @@ -553,20 +553,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } gtest.C(t, func(t *gtest.T) { @@ -668,20 +668,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } gtest.C(t, func(t *gtest.T) { @@ -809,20 +809,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } @@ -945,20 +945,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } gtest.C(t, func(t *gtest.T) { @@ -1065,20 +1065,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } db.SetDebug(true) @@ -1184,20 +1184,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } gtest.C(t, func(t *gtest.T) { @@ -1299,20 +1299,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } @@ -1439,20 +1439,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } @@ -1585,20 +1585,20 @@ PRIMARY KEY (id) "id": i, "name": fmt.Sprintf(`name_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Detail. _, err = db.Insert(ctx, tableUserDetail, g.Map{ "uid": i, "address": fmt.Sprintf(`address_%d`, i), }) - gtest.Assert(err, nil) + gtest.AssertNil(err) // Scores. for j := 1; j <= 5; j++ { _, err = db.Insert(ctx, tableUserScores, g.Map{ "uid": i, "score": j, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) } } diff --git a/database/gdb/gdb_z_mysql_model_test.go b/database/gdb/gdb_z_mysql_model_test.go index f9f87dcd1..4b941e223 100644 --- a/database/gdb/gdb_z_mysql_model_test.go +++ b/database/gdb/gdb_z_mysql_model_test.go @@ -2067,7 +2067,7 @@ func Test_Model_OmitEmpty(t *testing.T) { "id": 1, "name": "", }).Save() - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -2096,14 +2096,14 @@ func Test_Model_OmitNil(t *testing.T) { "id": 1, "name": "", }).Save() - t.Assert(err, nil) + t.AssertNil(err) }) gtest.C(t, func(t *gtest.T) { _, err := db.Model(table).OmitNilWhere().Data(g.Map{ "id": 1, "name": "", }).Save() - t.Assert(err, nil) + t.AssertNil(err) }) } diff --git a/database/gredis/gredis_z_unit_conn_test.go b/database/gredis/gredis_z_unit_conn_test.go index f3f6b1bd0..d77c2ce1f 100644 --- a/database/gredis/gredis_z_unit_conn_test.go +++ b/database/gredis/gredis_z_unit_conn_test.go @@ -30,11 +30,11 @@ func TestConn_DoWithTimeout(t *testing.T) { defer conn.Close(ctx) _, err = conn.Do(ctx, "set", "test", "123") - t.Assert(err, nil) + t.AssertNil(err) defer conn.Do(ctx, "del", "test") r, err := conn.Do(ctx, "get", "test") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.String(), "123") }) } diff --git a/database/gredis/gredis_z_unit_test.go b/database/gredis/gredis_z_unit_test.go index dfa5daa68..2671fbc97 100644 --- a/database/gredis/gredis_z_unit_test.go +++ b/database/gredis/gredis_z_unit_test.go @@ -46,16 +46,16 @@ func Test_Do(t *testing.T) { defer redis.Close(ctx) _, err = redis.Do(ctx, "SET", "k", "v") - t.Assert(err, nil) + t.AssertNil(err) r, err := redis.Do(ctx, "GET", "k") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, []byte("v")) _, err = redis.Do(ctx, "DEL", "k") - t.Assert(err, nil) + t.AssertNil(err) r, err = redis.Do(ctx, "GET", "k") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, nil) }) } @@ -74,16 +74,16 @@ func Test_Conn(t *testing.T) { key := gconv.String(gtime.TimestampNano()) value := []byte("v") r, err := conn.Do(ctx, "SET", key, value) - t.Assert(err, nil) + t.AssertNil(err) r, err = conn.Do(ctx, "GET", key) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, value) _, err = conn.Do(ctx, "DEL", key) - t.Assert(err, nil) + t.AssertNil(err) r, err = conn.Do(ctx, "GET", key) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, nil) }) } @@ -102,16 +102,16 @@ func Test_Instance(t *testing.T) { defer conn.Close(ctx) _, err = conn.Do(ctx, "SET", "k", "v") - t.Assert(err, nil) + t.AssertNil(err) r, err := conn.Do(ctx, "GET", "k") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, []byte("v")) _, err = conn.Do(ctx, "DEL", "k") - t.Assert(err, nil) + t.AssertNil(err) r, err = conn.Do(ctx, "GET", "k") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, nil) }) } @@ -153,10 +153,10 @@ func Test_Error(t *testing.T) { defer redis.Close(ctx) _, err = redis.Do(ctx, "SET", "k", "v") - t.Assert(err, nil) + t.AssertNil(err) v, err := redis.Do(ctx, "GET", "k") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.String(), "v") conn, err := redis.Conn(ctx) @@ -197,17 +197,17 @@ func Test_Bool(t *testing.T) { }() _, err = redis.Do(ctx, "SET", "key-true", true) - t.Assert(err, nil) + t.AssertNil(err) _, err = redis.Do(ctx, "SET", "key-false", false) - t.Assert(err, nil) + t.AssertNil(err) r, err := redis.Do(ctx, "GET", "key-true") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Bool(), true) r, err = redis.Do(ctx, "GET", "key-false") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Bool(), false) }) } @@ -223,10 +223,10 @@ func Test_Int(t *testing.T) { defer redis.Do(ctx, "DEL", key) _, err = redis.Do(ctx, "SET", key, 1) - t.Assert(err, nil) + t.AssertNil(err) r, err := redis.Do(ctx, "GET", key) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Int(), 1) }) } @@ -242,10 +242,10 @@ func Test_HSet(t *testing.T) { defer redis.Do(ctx, "DEL", key) _, err = redis.Do(ctx, "HSET", key, "name", "john") - t.Assert(err, nil) + t.AssertNil(err) r, err := redis.Do(ctx, "HGETALL", key) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Strings(), g.ArrayStr{"name", "john"}) }) } @@ -262,12 +262,12 @@ func Test_HGetAll1(t *testing.T) { defer redis.Do(ctx, "DEL", key) _, err = redis.Do(ctx, "HSET", key, "id", 100) - t.Assert(err, nil) + t.AssertNil(err) _, err = redis.Do(ctx, "HSET", key, "name", "john") - t.Assert(err, nil) + t.AssertNil(err) r, err := redis.Do(ctx, "HGETALL", key) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Map(), g.MapStrAny{ "id": 100, "name": "john", @@ -287,12 +287,12 @@ func Test_HGetAll2(t *testing.T) { defer redis.Do(ctx, "DEL", key) _, err = redis.Do(ctx, "HSET", key, "id", 100) - t.Assert(err, nil) + t.AssertNil(err) _, err = redis.Do(ctx, "HSET", key, "name", "john") - t.Assert(err, nil) + t.AssertNil(err) result, err := redis.Do(ctx, "HGETALL", key) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gconv.Uint(result.MapStrVar()["id"]), 100) t.Assert(result.MapStrVar()["id"].Uint(), 100) @@ -317,9 +317,9 @@ func Test_HMSet(t *testing.T) { defer redis.Do(ctx, "DEL", key) _, err = redis.Do(ctx, "HMSET", append(g.Slice{key}, gutil.MapToSlice(data)...)...) - t.Assert(err, nil) + t.AssertNil(err) v, err := redis.Do(ctx, "HMGET", key, "name") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Slice(), g.Slice{data["name"]}) }) // struct @@ -344,9 +344,9 @@ func Test_HMSet(t *testing.T) { defer redis.Do(ctx, "DEL", key) _, err = redis.Do(ctx, "HMSET", append(g.Slice{key}, gutil.StructToSlice(data)...)...) - t.Assert(err, nil) + t.AssertNil(err) v, err := redis.Do(ctx, "HMGET", key, "name") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Slice(), g.Slice{data.Name}) }) } @@ -374,10 +374,10 @@ func Test_Auto_Marshal(t *testing.T) { } _, err = redis.Do(ctx, "SET", key, user) - t.Assert(err, nil) + t.AssertNil(err) r, err := redis.Do(ctx, "GET", key) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Map(), g.MapStrAny{ "Id": user.Id, "Name": user.Name, @@ -418,14 +418,14 @@ func Test_Auto_MarshalSlice(t *testing.T) { ) _, err = redis.Do(ctx, "SET", key, users1) - t.Assert(err, nil) + t.AssertNil(err) result, err = redis.Do(ctx, "GET", key) - t.Assert(err, nil) + t.AssertNil(err) var users2 []User err = result.Structs(&users2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(users2, users1) }) } diff --git a/encoding/gbase64/gbase64_z_unit_test.go b/encoding/gbase64/gbase64_z_unit_test.go index d77921e63..4e02ceada 100644 --- a/encoding/gbase64/gbase64_z_unit_test.go +++ b/encoding/gbase64/gbase64_z_unit_test.go @@ -70,12 +70,12 @@ func Test_File(t *testing.T) { expect := "dGVzdA==" gtest.C(t, func(t *gtest.T) { b, err := gbase64.EncodeFile(path) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(b), expect) }) gtest.C(t, func(t *gtest.T) { s, err := gbase64.EncodeFileToString(path) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(s, expect) }) } diff --git a/encoding/gcompress/gcompress_z_unit_gzip_test.go b/encoding/gcompress/gcompress_z_unit_gzip_test.go index a5836c3b1..4bc86a615 100644 --- a/encoding/gcompress/gcompress_z_unit_gzip_test.go +++ b/encoding/gcompress/gcompress_z_unit_gzip_test.go @@ -50,13 +50,13 @@ func Test_Gzip_UnGzip_File(t *testing.T) { // Compress. gtest.C(t, func(t *gtest.T) { err := gcompress.GzipFile(srcPath, dstPath1, 9) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dstPath1) t.Assert(gfile.Exists(dstPath1), true) // Decompress. err = gcompress.UnGzipFile(dstPath1, dstPath2) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dstPath2) t.Assert(gfile.Exists(dstPath2), true) diff --git a/encoding/gcompress/gcompress_z_unit_zip_test.go b/encoding/gcompress/gcompress_z_unit_zip_test.go index 45a40715f..b44069d4b 100644 --- a/encoding/gcompress/gcompress_z_unit_zip_test.go +++ b/encoding/gcompress/gcompress_z_unit_zip_test.go @@ -52,7 +52,7 @@ func Test_ZipPath(t *testing.T) { t.Assert(gfile.Exists(dstPath), false) err := gcompress.ZipPath(srcPath1+","+srcPath2, dstPath) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.Exists(dstPath), true) defer gfile.Remove(dstPath) @@ -60,7 +60,7 @@ func Test_ZipPath(t *testing.T) { tempDirPath := gfile.Temp(gtime.TimestampNanoStr()) t.Assert(gfile.Mkdir(tempDirPath), nil) err = gcompress.UnZipFile(dstPath, tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(tempDirPath) t.Assert( @@ -85,7 +85,7 @@ func Test_ZipPath(t *testing.T) { t.Assert(gfile.Exists(dstPath), false) err := gcompress.ZipPath(srcPath1+","+srcPath2, dstPath) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.Exists(dstPath), true) defer gfile.Remove(dstPath) @@ -93,7 +93,7 @@ func Test_ZipPath(t *testing.T) { tempDirPath := gfile.Temp(gtime.TimestampNanoStr()) t.Assert(gfile.Mkdir(tempDirPath), nil) err = gcompress.UnZipFile(dstPath, tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(tempDirPath) t.Assert( @@ -113,20 +113,20 @@ func Test_ZipPath(t *testing.T) { pwd := gfile.Pwd() err := gfile.Chdir(srcPath) defer gfile.Chdir(pwd) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.Exists(dstPath), false) err = gcompress.ZipPath(srcPath, dstPath) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.Exists(dstPath), true) defer gfile.Remove(dstPath) tempDirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) err = gcompress.UnZipFile(dstPath, tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(tempDirPath) t.Assert( @@ -149,22 +149,22 @@ func Test_ZipPath(t *testing.T) { pwd := gfile.Pwd() err := gfile.Chdir(srcPath) defer gfile.Chdir(pwd) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.Exists(dstPath), false) err = gcompress.ZipPath(srcPath1+", "+srcPath2, dstPath) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.Exists(dstPath), true) defer gfile.Remove(dstPath) tempDirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) zipContent := gfile.GetBytes(dstPath) t.AssertGT(len(zipContent), 0) err = gcompress.UnZipContent(zipContent, tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(tempDirPath) t.Assert( @@ -188,22 +188,22 @@ func Test_ZipPathWriter(t *testing.T) { pwd := gfile.Pwd() err := gfile.Chdir(srcPath) defer gfile.Chdir(pwd) - t.Assert(err, nil) + t.AssertNil(err) writer := bytes.NewBuffer(nil) t.Assert(writer.Len(), 0) err = gcompress.ZipPathWriter(srcPath1+", "+srcPath2, writer) - t.Assert(err, nil) + t.AssertNil(err) t.AssertGT(writer.Len(), 0) tempDirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) zipContent := writer.Bytes() t.AssertGT(len(zipContent), 0) err = gcompress.UnZipContent(zipContent, tempDirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(tempDirPath) t.Assert( diff --git a/encoding/ghtml/ghtml_z_unit_test.go b/encoding/ghtml/ghtml_z_unit_test.go index 0c70e2a85..8ac444753 100644 --- a/encoding/ghtml/ghtml_z_unit_test.go +++ b/encoding/ghtml/ghtml_z_unit_test.go @@ -47,7 +47,7 @@ func Test_SpecialCharsMapOrStruct_Map(t *testing.T) { "Content": "
C
", } err := ghtml.SpecialCharsMapOrStruct(a) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a["Title"], `<h1>T</h1>`) t.Assert(a["Content"], `<div>C</div>`) }) @@ -57,7 +57,7 @@ func Test_SpecialCharsMapOrStruct_Map(t *testing.T) { "Content": "
C
", } err := ghtml.SpecialCharsMapOrStruct(a) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a["Title"], `<h1>T</h1>`) t.Assert(a["Content"], `<div>C</div>`) }) @@ -74,7 +74,7 @@ func Test_SpecialCharsMapOrStruct_Struct(t *testing.T) { Content: "
C
", } err := ghtml.SpecialCharsMapOrStruct(a) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a.Title, `<h1>T</h1>`) t.Assert(a.Content, `<div>C</div>`) }) diff --git a/encoding/gini/gini_z_unit_test.go b/encoding/gini/gini_z_unit_test.go index 2a3239bce..e3001f7f3 100644 --- a/encoding/gini/gini_z_unit_test.go +++ b/encoding/gini/gini_z_unit_test.go @@ -97,7 +97,7 @@ func TestToJson(t *testing.T) { } iniMap, err := gini.Decode([]byte(iniContent)) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(iniMap["addr"].(map[string]interface{})["ip"], json.Get("addr.ip").String()) t.Assert(iniMap["addr"].(map[string]interface{})["port"], json.Get("addr.port").String()) diff --git a/encoding/gjson/gjson_z_unit_feature_json_test.go b/encoding/gjson/gjson_z_unit_feature_json_test.go index a7d1f89ad..5e3cd3024 100644 --- a/encoding/gjson/gjson_z_unit_feature_json_test.go +++ b/encoding/gjson/gjson_z_unit_feature_json_test.go @@ -36,7 +36,7 @@ func Test_ToJson(t *testing.T) { jsonContent := `{"dataSetId":2001,"fieldInfos":{"duration":{"id":80079,"value":"59"},"om_level":{"id":2409,"value":"4"}},"id":"g0936lt1u0f","modifyFieldInfos":{"om_level":{"id":2409,"new":"4","old":""}},"timeStamp":1584599734}` var info MediaRequestModifyInfo err := gjson.DecodeTo(jsonContent, &info) - t.Assert(err, nil) + t.AssertNil(err) content := gjson.New(info).MustToJsonString() t.Assert(gstr.Contains(content, `"feed_id":""`), true) t.Assert(gstr.Contains(content, `"fieldInfos":{`), true) @@ -56,14 +56,14 @@ func Test_MapAttributeConvert(t *testing.T) { ` gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) + gtest.AssertNil(err) tx := struct { Title map[string]interface{} }{} err = j.Var().Scan(&tx) - gtest.Assert(err, nil) + gtest.AssertNil(err) t.Assert(tx.Title, g.Map{ "l1": "标签1", "l2": "标签2", }) @@ -76,14 +76,14 @@ func Test_MapAttributeConvert(t *testing.T) { gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) + gtest.AssertNil(err) tx := struct { Title map[string]string }{} err = j.Var().Scan(&tx) - gtest.Assert(err, nil) + gtest.AssertNil(err) t.Assert(tx.Title, g.Map{ "l1": "标签1", "l2": "标签2", }) diff --git a/encoding/gjson/gjson_z_unit_feature_load_test.go b/encoding/gjson/gjson_z_unit_feature_load_test.go index c4ae26bff..4517989a4 100644 --- a/encoding/gjson/gjson_z_unit_feature_load_test.go +++ b/encoding/gjson/gjson_z_unit_feature_load_test.go @@ -20,7 +20,7 @@ func Test_Load_JSON1(t *testing.T) { // JSON gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -39,7 +39,7 @@ func Test_Load_JSON1(t *testing.T) { gfile.PutBytes(path, data) defer gfile.Remove(path) j, err := gjson.Load(path, true) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -52,7 +52,7 @@ func Test_Load_JSON2(t *testing.T) { data := []byte(`{"n":123456789000000000000, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789000000000000") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -66,7 +66,7 @@ func Test_Load_XML(t *testing.T) { // XML gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("doc.n").String(), "123456789") t.Assert(j.Get("doc.m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("doc.m.k").String(), "v") @@ -76,7 +76,7 @@ func Test_Load_XML(t *testing.T) { // XML gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadXml(data, true) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("doc.n").String(), "123456789") t.Assert(j.Get("doc.m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("doc.m.k").String(), "v") @@ -95,7 +95,7 @@ func Test_Load_XML(t *testing.T) { gfile.PutBytes(path, data) defer gfile.Remove(path) j, err := gjson.Load(path) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("doc.n").String(), "123456789") t.Assert(j.Get("doc.m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("doc.m.k").String(), "v") @@ -116,7 +116,7 @@ func Test_Load_XML(t *testing.T) { ` j, err := gjson.LoadContent(xml) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Output.ipageIndex"), "2") t.Assert(j.Get("Output.itotalRecords"), "GF框架") }) @@ -135,7 +135,7 @@ m: // YAML gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -145,7 +145,7 @@ m: // YAML gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadYaml(data, true) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -158,7 +158,7 @@ m: gfile.PutBytes(path, data) defer gfile.Remove(path) j, err := gjson.Load(path) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -171,7 +171,7 @@ func Test_Load_YAML2(t *testing.T) { data := []byte("i : 123456789") gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("i"), "123456789") }) gtest.C(t, func(t *gtest.T) { @@ -192,7 +192,7 @@ n = 123456789 // TOML gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -202,7 +202,7 @@ n = 123456789 // TOML gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadToml(data, true) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -215,7 +215,7 @@ n = 123456789 gfile.PutBytes(path, data) defer gfile.Remove(path) j, err := gjson.Load(path) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -228,7 +228,7 @@ func Test_Load_TOML2(t *testing.T) { data := []byte("i=123456789") gtest.C(t, func(t *gtest.T) { j, err := gjson.LoadContent(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("i"), "123456789") }) gtest.C(t, func(t *gtest.T) { @@ -247,11 +247,11 @@ func Test_Load_Basic(t *testing.T) { _, err = gjson.DecodeToJson(nil) t.AssertNE(err, nil) j, err = gjson.LoadContent(nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Interface(), nil) j, err = gjson.LoadContent(`{"name": "gf"}`) - t.Assert(err, nil) + t.AssertNil(err) j, err = gjson.LoadContent(`{"name": "gf"""}`) t.AssertNE(err, nil) diff --git a/encoding/gjson/gjson_z_unit_feature_new_test.go b/encoding/gjson/gjson_z_unit_feature_new_test.go index 38e844649..b5695af1b 100644 --- a/encoding/gjson/gjson_z_unit_feature_new_test.go +++ b/encoding/gjson/gjson_z_unit_feature_new_test.go @@ -65,7 +65,7 @@ func Test_New_CustomStruct(t *testing.T) { t.AssertNE(j, nil) s, err := j.ToJsonString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(s == `{"Id":1,"Name":"john"}` || s == `{"Name":"john","Id":1}`, true) }) } diff --git a/encoding/gjson/gjson_z_unit_feature_set_test.go b/encoding/gjson/gjson_z_unit_feature_set_test.go index a389d0f79..0e48d5290 100644 --- a/encoding/gjson/gjson_z_unit_feature_set_test.go +++ b/encoding/gjson/gjson_z_unit_feature_set_test.go @@ -236,7 +236,7 @@ func Test_Set15(t *testing.T) { t.Assert(j.Set("k", "v"), nil) s, err := j.ToJsonString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert( gstr.Contains(s, `"root":[{"k1":"v1"},{"k2":"v2"}`) || gstr.Contains(s, `"root":[{"k2":"v2"},{"k1":"v1"}`), @@ -259,7 +259,7 @@ func Test_Set16(t *testing.T) { t.Assert(j.Set("description", "3"), nil) s, err := j.ToJsonString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert( gstr.Contains(s, `"processors":[{"set":{"0field":"2","0value":"1"}}]`) || gstr.Contains(s, `"processors":[{"set":{"0value":"1","0field":"2"}}]`), @@ -282,7 +282,7 @@ func Test_Set17(t *testing.T) { t.Assert(j.Set("k", "v"), nil) s, err := j.ToJsonString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(s, `{"k":"v"}`) }) } @@ -294,7 +294,7 @@ func Test_Set18(t *testing.T) { t.Assert(j.Set("0.1.k1", "v1"), nil) t.Assert(j.Set("0.2.k2", "v2"), nil) s, err := j.ToJsonString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(s, `[[null,{"k1":"v1"},{"k2":"v2"}]]`) }) } @@ -306,7 +306,7 @@ func Test_Set19(t *testing.T) { t.Assert(j.Set("0.1.1.k1", "v1"), nil) t.Assert(j.Set("0.2.1.k2", "v2"), nil) s, err := j.ToJsonString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(s, `[[null,[null,{"k1":"v1"}],[null,{"k2":"v2"}]]]`) }) } @@ -320,7 +320,7 @@ func Test_Set20(t *testing.T) { t.Assert(j.Set("k2.1", 20), nil) t.Assert(j.Set("k2.2", g.Map{"k3": "v3"}), nil) s, err := j.ToJsonString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gstr.InArray( g.SliceStr{ `{"k1":"v1","k2":[1,20,{"k3":"v3"}]}`, diff --git a/encoding/gjson/gjson_z_unit_feature_struct_test.go b/encoding/gjson/gjson_z_unit_feature_struct_test.go index b7c514ff2..49f7c0a4a 100644 --- a/encoding/gjson/gjson_z_unit_feature_struct_test.go +++ b/encoding/gjson/gjson_z_unit_feature_struct_test.go @@ -22,7 +22,7 @@ func Test_GetScan(t *testing.T) { gtest.C(t, func(t *gtest.T) { var user *User err := j.Get("1").Scan(&user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user, &User{ Name: "smith", Score: 60, @@ -31,7 +31,7 @@ func Test_GetScan(t *testing.T) { gtest.C(t, func(t *gtest.T) { var users []User err := j.Get(".").Scan(&users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(users, []User{ { Name: "john", @@ -54,7 +54,7 @@ func Test_GetScanDeep(t *testing.T) { gtest.C(t, func(t *gtest.T) { var user *User err := j.Get("1").Scan(&user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user, &User{ Name: "smith", Score: 60, @@ -63,7 +63,7 @@ func Test_GetScanDeep(t *testing.T) { gtest.C(t, func(t *gtest.T) { var users []User err := j.Get(".").Scan(&users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(users, []User{ { Name: "john", @@ -86,7 +86,7 @@ func Test_Scan1(t *testing.T) { gtest.C(t, func(t *gtest.T) { var users []User err := j.Var().Scan(&users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(users, []User{ { Name: "john", @@ -109,7 +109,7 @@ func Test_Scan2(t *testing.T) { gtest.C(t, func(t *gtest.T) { var users []User err := j.Var().Scan(&users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(users, []User{ { Name: "john", @@ -198,9 +198,9 @@ func Test_Struct1(t *testing.T) { }` data := new(UserCollectionAddReq) j, err := gjson.LoadJson(jsonContent, true) - t.Assert(err, nil) + t.AssertNil(err) err = j.Scan(data) - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -226,14 +226,14 @@ func Test_Struct(t *testing.T) { }` j, err := gjson.LoadContent(txt) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("me.name").String(), "mikey") t.Assert(j.Get("items").String(), "") t.Assert(j.Get("items").Bool(), false) t.Assert(j.Get("items").Array(), nil) m := new(M) err = j.Scan(m) - t.Assert(err, nil) + t.AssertNil(err) t.AssertNE(m.Me, nil) t.Assert(m.Me["day"], "20009") t.Assert(m.Items, nil) @@ -289,10 +289,10 @@ func Test_Struct_Complicated(t *testing.T) { ] }` j, err := gjson.LoadContent(jsonContent) - t.Assert(err, nil) + t.AssertNil(err) var response = new(Response) err = j.Scan(response) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(response.CertList), 3) t.Assert(response.CertList[0].CertID, 2023313) t.Assert(response.CertList[1].CertID, 2023314) diff --git a/encoding/gjson/gjson_z_unit_implements_test.go b/encoding/gjson/gjson_z_unit_implements_test.go index e0aaec6f2..a47746e3d 100644 --- a/encoding/gjson/gjson_z_unit_implements_test.go +++ b/encoding/gjson/gjson_z_unit_implements_test.go @@ -24,7 +24,7 @@ func TestJson_UnmarshalJSON(t *testing.T) { j = gjson.New(nil) err = json.UnmarshalUseNumber(data, j) ) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get(".").String(), `["a","b","c"]`) t.Assert(j.Get("2").String(), `c`) }) @@ -35,7 +35,7 @@ func TestJson_UnmarshalJSON(t *testing.T) { j = gjson.New(nil) err = json.UnmarshalUseNumber(data, j) ) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get(".").String(), `[{"a":1},{"b":2},{"c":3}]`) t.Assert(j.Get("2.c").String(), `3`) }) @@ -46,7 +46,7 @@ func TestJson_UnmarshalJSON(t *testing.T) { j = gjson.New(nil) err = json.UnmarshalUseNumber(data, j) ) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k").String(), "v") @@ -68,7 +68,7 @@ func TestJson_UnmarshalValue(t *testing.T) { "name": "john", "json": []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`), }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Json.Get("n").String(), "123456789") t.Assert(v.Json.Get("m").Map(), g.Map{"k": "v"}) @@ -83,7 +83,7 @@ func TestJson_UnmarshalValue(t *testing.T) { "name": "john", "json": `["a", "b", "c"]`, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Json.Get(".").String(), `["a","b","c"]`) t.Assert(v.Json.Get("2").String(), `c`) @@ -95,7 +95,7 @@ func TestJson_UnmarshalValue(t *testing.T) { "name": "john", "json": `[{"a":1},{"b":2},{"c":3}]`, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Json.Get(".").String(), `[{"a":1},{"b":2},{"c":3}]`) t.Assert(v.Json.Get("2.c").String(), `3`) @@ -111,7 +111,7 @@ func TestJson_UnmarshalValue(t *testing.T) { "a": g.Slice{1, 2, 3}, }, }, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v.Name, "john") t.Assert(v.Json.Get("n").String(), "123456789") t.Assert(v.Json.Get("m").Map(), g.Map{"k": "v"}) diff --git a/encoding/gjson/gjson_z_unit_test.go b/encoding/gjson/gjson_z_unit_test.go index cc07a1d49..6691024c6 100644 --- a/encoding/gjson/gjson_z_unit_test.go +++ b/encoding/gjson/gjson_z_unit_test.go @@ -66,7 +66,7 @@ func Test_Encode(t *testing.T) { value := g.Slice{1, 2, 3} gtest.C(t, func(t *gtest.T) { b, err := gjson.Encode(value) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(b, []byte(`[1,2,3]`)) }) } @@ -75,7 +75,7 @@ func Test_Decode(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { v, err := gjson.Decode(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v, g.Map{ "n": 123456789, "a": g.Slice{1, 2, 3}, @@ -87,7 +87,7 @@ func Test_Decode(t *testing.T) { gtest.C(t, func(t *gtest.T) { var v interface{} err := gjson.DecodeTo(data, &v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v, g.Map{ "n": 123456789, "a": g.Slice{1, 2, 3}, @@ -98,7 +98,7 @@ func Test_Decode(t *testing.T) { }) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m.k"), "v") @@ -112,7 +112,7 @@ func Test_SplitChar(t *testing.T) { gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) j.SetSplitChar(byte('#')) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("m#k").String(), "v") @@ -125,7 +125,7 @@ func Test_ViolenceCheck(t *testing.T) { data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("m.a.2"), 3) t.Assert(j.Get("m.v1.v2"), nil) j.SetViolenceCheck(true) @@ -137,7 +137,7 @@ func Test_GetVar(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").String(), "123456789") t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("a").Interfaces(), g.Slice{1, 2, 3}) @@ -150,7 +150,7 @@ func Test_GetMap(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").Map(), nil) t.Assert(j.Get("m").Map(), g.Map{"k": "v"}) t.Assert(j.Get("a").Map(), g.Map{"1": "2", "3": nil}) @@ -161,7 +161,7 @@ func Test_GetJson(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) j2 := j.GetJson("m") t.AssertNE(j2, nil) t.Assert(j2.Get("k"), "v") @@ -174,7 +174,7 @@ func Test_GetArray(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("n").Array(), g.Array{123456789}) t.Assert(j.Get("m").Array(), g.Array{g.Map{"k": "v"}}) t.Assert(j.Get("a").Array(), g.Array{1, 2, 3}) @@ -185,7 +185,7 @@ func Test_GetString(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(j.Get("n").String(), "123456789") t.AssertEQ(j.Get("m").String(), `{"k":"v"}`) t.AssertEQ(j.Get("a").String(), `[1,2,3]`) @@ -197,7 +197,7 @@ func Test_GetStrings(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(j.Get("n").Strings(), g.SliceStr{"123456789"}) t.AssertEQ(j.Get("m").Strings(), g.SliceStr{`{"k":"v"}`}) t.AssertEQ(j.Get("a").Strings(), g.SliceStr{"1", "2", "3"}) @@ -209,7 +209,7 @@ func Test_GetInterfaces(t *testing.T) { data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) gtest.C(t, func(t *gtest.T) { j, err := gjson.DecodeToJson(data) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(j.Get("n").Interfaces(), g.Array{123456789}) t.AssertEQ(j.Get("m").Interfaces(), g.Array{g.Map{"k": "v"}}) t.AssertEQ(j.Get("a").Interfaces(), g.Array{1, 2, 3}) @@ -332,37 +332,37 @@ func Test_Convert(t *testing.T) { gtest.C(t, func(t *gtest.T) { j := gjson.New(`{"name":"gf"}`) arr, err := j.ToXml() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "gf") arr, err = j.ToXmlIndent() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "gf") str, err := j.ToXmlString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(str, "gf") str, err = j.ToXmlIndentString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(str, "gf") arr, err = j.ToJsonIndent() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}") str, err = j.ToJsonIndentString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}") arr, err = j.ToYaml() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "name: gf\n") str, err = j.ToYamlString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "name: gf\n") arr, err = j.ToToml() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "name = \"gf\"\n") str, err = j.ToTomlString() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(arr), "name = \"gf\"\n") }) } @@ -387,19 +387,19 @@ func Test_Convert2(t *testing.T) { t.Assert(j.Get("time").Duration().String(), "0s") err := j.Var().Scan(&name) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(name.Name, "gf") // j.Dump() - t.Assert(err, nil) + t.AssertNil(err) j = gjson.New(`{"person":{"name":"gf"}}`) err = j.Get("person").Scan(&name) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(name.Name, "gf") j = gjson.New(`{"name":"gf""}`) // j.Dump() - t.Assert(err, nil) + t.AssertNil(err) j = gjson.New(`[1,2,3]`) t.Assert(len(j.Var().Array()), 3) @@ -417,12 +417,12 @@ func Test_Basic(t *testing.T) { t.Assert(j.Get(".").Interface().(g.Map)["name"], "gf") err := j.Set("name", "gf1") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("name"), "gf1") j = gjson.New(`[1,2,3]`) err = j.Set("\"0\".1", 11) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("1"), 11) j = gjson.New(`[1,2,3]`) @@ -431,7 +431,7 @@ func Test_Basic(t *testing.T) { j = gjson.New(`[1,2,3]`) err = j.Remove("1") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("0"), 1) t.Assert(len(j.Var().Array()), 2) @@ -445,18 +445,18 @@ func Test_Basic(t *testing.T) { j = gjson.New(`[1,2,3]`) err = j.Remove("3") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("0"), 1) t.Assert(len(j.Var().Array()), 3) j = gjson.New(`[1,2,3]`) err = j.Remove("0.3") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("0"), 1) j = gjson.New(`[1,2,3]`) err = j.Remove("0.a") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("0"), 1) name := struct { @@ -465,35 +465,35 @@ func Test_Basic(t *testing.T) { j = gjson.New(name) t.Assert(j.Get("Name"), "gf") err = j.Remove("Name") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name"), nil) err = j.Set("Name", "gf1") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name"), "gf1") j = gjson.New(nil) err = j.Remove("Name") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name"), nil) j = gjson.New(name) t.Assert(j.Get("Name"), "gf") err = j.Set("Name1", g.Map{"Name": "gf1"}) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name1").Interface().(g.Map)["Name"], "gf1") err = j.Set("Name2", g.Slice{1, 2, 3}) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name2").Interface().(g.Slice)[0], 1) err = j.Set("Name3", name) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name3").Interface().(g.Map)["Name"], "gf") err = j.Set("Name4", &name) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name4").Interface().(g.Map)["Name"], "gf") arr := [3]int{1, 2, 3} err = j.Set("Name5", arr) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(j.Get("Name5").Interface().(g.Array)[0], 1) }) diff --git a/encoding/gxml/gxml_z_unit_test.go b/encoding/gxml/gxml_z_unit_test.go index 35a80e32a..649e730fc 100644 --- a/encoding/gxml/gxml_z_unit_test.go +++ b/encoding/gxml/gxml_z_unit_test.go @@ -112,7 +112,7 @@ func Test_Decode2(t *testing.T) { johngcn123456123456 ` m, err := gxml.Decode([]byte(content)) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m["doc"].(map[string]interface{})["username"], "johngcn") t.Assert(m["doc"].(map[string]interface{})["password1"], "123456") t.Assert(m["doc"].(map[string]interface{})["password2"], "123456") @@ -125,7 +125,7 @@ func Test_DecodeWitoutRoot(t *testing.T) { johngcn123456123456 ` m, err := gxml.DecodeWithoutRoot([]byte(content)) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m["username"], "johngcn") t.Assert(m["password1"], "123456") t.Assert(m["password2"], "123456") diff --git a/encoding/gyaml/gyaml_z_unit_test.go b/encoding/gyaml/gyaml_z_unit_test.go index c840f4ef0..10a480982 100644 --- a/encoding/gyaml/gyaml_z_unit_test.go +++ b/encoding/gyaml/gyaml_z_unit_test.go @@ -74,7 +74,7 @@ func Test_EncodeIndent(t *testing.T) { func Test_Decode(t *testing.T) { gtest.C(t, func(t *gtest.T) { result, err := gyaml.Decode([]byte(yamlStr)) - t.Assert(err, nil) + t.AssertNil(err) m, ok := result.(map[string]interface{}) t.Assert(ok, true) @@ -92,7 +92,7 @@ func Test_DecodeTo(t *testing.T) { gtest.C(t, func(t *gtest.T) { result := make(map[string]interface{}) err := gyaml.DecodeTo([]byte(yamlStr), &result) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, map[string]interface{}{ "url": "https://goframe.org", "server": g.Slice{"120.168.117.21", "120.168.117.22"}, @@ -121,9 +121,9 @@ m: k: v `) v, err := gyaml.Decode(data) - t.Assert(err, nil) + t.AssertNil(err) b, err := json.Marshal(v) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(b, `{"m":{"k":"v"}}`) }) } diff --git a/errors/gerror/gerror_z_unit_test.go b/errors/gerror/gerror_z_unit_test.go index f4aa6b2df..228cb91df 100644 --- a/errors/gerror/gerror_z_unit_test.go +++ b/errors/gerror/gerror_z_unit_test.go @@ -251,7 +251,7 @@ func Test_Next(t *testing.T) { t.Assert(err.Error(), "1") err = gerror.Next(err) - t.Assert(err, nil) + t.AssertNil(err) }) } diff --git a/frame/gins/gins_z_unit_config_test.go b/frame/gins/gins_z_unit_config_test.go index 1395e34d6..ddfc98915 100644 --- a/frame/gins/gins_z_unit_config_test.go +++ b/frame/gins/gins_z_unit_config_test.go @@ -42,15 +42,15 @@ func Test_Config2(t *testing.T) { var err error dirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dirPath) name := "config.toml" err = gfile.PutContents(gfile.Join(dirPath, name), configContent) - t.Assert(err, nil) + t.AssertNil(err) err = gins.Config().GetAdapter().(*gcfg.AdapterFile).AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gins.Config().GetAdapter().(*gcfg.AdapterFile).Clear() @@ -91,15 +91,15 @@ func Test_Config3(t *testing.T) { var err error dirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dirPath) name := "test.toml" err = gfile.PutContents(gfile.Join(dirPath, name), configContent) - t.Assert(err, nil) + t.AssertNil(err) err = gins.Config("test").GetAdapter().(*gcfg.AdapterFile).AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gins.Config("test").GetAdapter().(*gcfg.AdapterFile).Clear() gins.Config("test").GetAdapter().(*gcfg.AdapterFile).SetFileName("test.toml") @@ -115,15 +115,15 @@ func Test_Config3(t *testing.T) { var err error dirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dirPath) name := "config/test.toml" err = gfile.PutContents(gfile.Join(dirPath, name), configContent) - t.Assert(err, nil) + t.AssertNil(err) err = gins.Config("test").GetAdapter().(*gcfg.AdapterFile).AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gins.Config("test").GetAdapter().(*gcfg.AdapterFile).Clear() gins.Config("test").GetAdapter().(*gcfg.AdapterFile).SetFileName("test.toml") @@ -142,7 +142,7 @@ func Test_Config4(t *testing.T) { path := fmt.Sprintf(`%s/%d`, gfile.Temp(), gtime.TimestampNano()) file := fmt.Sprintf(`%s/%s`, path, "config.toml") err := gfile.PutContents(file, configContent) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(file) defer gins.Config().GetAdapter().(*gcfg.AdapterFile).Clear() @@ -157,7 +157,7 @@ func Test_Config4(t *testing.T) { path := fmt.Sprintf(`%s/%d/config`, gfile.Temp(), gtime.TimestampNano()) file := fmt.Sprintf(`%s/%s`, path, "config.toml") err := gfile.PutContents(file, configContent) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(file) defer gins.Config().GetAdapter().(*gcfg.AdapterFile).Clear() t.Assert(gins.Config().GetAdapter().(*gcfg.AdapterFile).AddPath(path), nil) @@ -171,7 +171,7 @@ func Test_Config4(t *testing.T) { path := fmt.Sprintf(`%s/%d`, gfile.Temp(), gtime.TimestampNano()) file := fmt.Sprintf(`%s/%s`, path, "test.toml") err := gfile.PutContents(file, configContent) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(file) defer gins.Config("test").GetAdapter().(*gcfg.AdapterFile).Clear() gins.Config("test").GetAdapter().(*gcfg.AdapterFile).SetFileName("test.toml") @@ -186,7 +186,7 @@ func Test_Config4(t *testing.T) { path := fmt.Sprintf(`%s/%d/config`, gfile.Temp(), gtime.TimestampNano()) file := fmt.Sprintf(`%s/%s`, path, "test.toml") err := gfile.PutContents(file, configContent) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(file) defer gins.Config().GetAdapter().(*gcfg.AdapterFile).Clear() gins.Config("test").GetAdapter().(*gcfg.AdapterFile).SetFileName("test.toml") diff --git a/frame/gins/gins_z_unit_database_test.go b/frame/gins/gins_z_unit_database_test.go index 6fd224f6f..5ec575660 100644 --- a/frame/gins/gins_z_unit_database_test.go +++ b/frame/gins/gins_z_unit_database_test.go @@ -26,15 +26,15 @@ func Test_Database(t *testing.T) { var err error dirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dirPath) name := "config.toml" err = gfile.PutContents(gfile.Join(dirPath, name), databaseContent) - t.Assert(err, nil) + t.AssertNil(err) err = gins.Config().GetAdapter().(*gcfg.AdapterFile).AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gins.Config().GetAdapter().(*gcfg.AdapterFile).Clear() diff --git a/frame/gins/gins_z_unit_redis_test.go b/frame/gins/gins_z_unit_redis_test.go index 7fe073a1a..237db241c 100644 --- a/frame/gins/gins_z_unit_redis_test.go +++ b/frame/gins/gins_z_unit_redis_test.go @@ -27,15 +27,15 @@ func Test_Redis(t *testing.T) { var err error dirPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dirPath) name := "config.toml" err = gfile.PutContents(gfile.Join(dirPath, name), redisContent) - t.Assert(err, nil) + t.AssertNil(err) err = gins.Config().GetAdapter().(*gcfg.AdapterFile).AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) defer gins.Config().GetAdapter().(*gcfg.AdapterFile).Clear() @@ -58,13 +58,13 @@ func Test_Redis(t *testing.T) { t.Assert(r, "PONG") r, err = redisCache.Do(ctx, "PING") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, "PONG") _, err = redisDisk.Do(ctx, "SET", "k", "v") - t.Assert(err, nil) + t.AssertNil(err) r, err = redisDisk.Do(ctx, "GET", "k") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, []byte("v")) }) } diff --git a/frame/gins/gins_z_unit_view_test.go b/frame/gins/gins_z_unit_view_test.go index f40e73730..bc66d5376 100644 --- a/frame/gins/gins_z_unit_view_test.go +++ b/frame/gins/gins_z_unit_view_test.go @@ -28,7 +28,7 @@ func Test_View(t *testing.T) { gtest.C(t, func(t *gtest.T) { tpl := "t.tpl" err := gfile.PutContents(tpl, `{{"我是中国人" | substr 2 -1}}`) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(tpl) b, e := View().Parse(context.TODO(), "t.tpl", nil) @@ -39,10 +39,10 @@ func Test_View(t *testing.T) { path := fmt.Sprintf(`%s/%d`, gfile.Temp(), gtime.TimestampNano()) tpl := fmt.Sprintf(`%s/%s`, path, "t.tpl") err := gfile.PutContents(tpl, `{{"我是中国人" | substr 2 -1}}`) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(tpl) err = View().AddPath(path) - t.Assert(err, nil) + t.AssertNil(err) b, e := View().Parse(context.TODO(), "t.tpl", nil) t.Assert(e, nil) @@ -61,16 +61,16 @@ func Test_View_Config(t *testing.T) { view := View("test1") t.AssertNE(view, nil) err := view.AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) str := `hello ${.name},version:${.version}` view.Assigns(map[string]interface{}{"version": "1.9.0"}) result, err := view.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "hello test1,version:1.9.0") result, err = view.ParseDefault(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "test1:test1") }) // view1 test2 @@ -83,16 +83,16 @@ func Test_View_Config(t *testing.T) { view := View("test2") t.AssertNE(view, nil) err := view.AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) str := `hello #{.name},version:#{.version}` view.Assigns(map[string]interface{}{"version": "1.9.0"}) result, err := view.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "hello test2,version:1.9.0") result, err = view.ParseDefault(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "test2:test2") }) // view2 @@ -105,16 +105,16 @@ func Test_View_Config(t *testing.T) { view := View() t.AssertNE(view, nil) err := view.AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) str := `hello {.name},version:{.version}` view.Assigns(map[string]interface{}{"version": "1.9.0"}) result, err := view.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "hello test,version:1.9.0") result, err = view.ParseDefault(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "test:test") }) // view2 @@ -127,16 +127,16 @@ func Test_View_Config(t *testing.T) { view := View("test100") t.AssertNE(view, nil) err := view.AddPath(dirPath) - t.Assert(err, nil) + t.AssertNil(err) str := `hello {.name},version:{.version}` view.Assigns(map[string]interface{}{"version": "1.9.0"}) result, err := view.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "hello test,version:1.9.0") result, err = view.ParseDefault(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "test:test") }) } diff --git a/i18n/gi18n/gi18n_z_unit_test.go b/i18n/gi18n/gi18n_z_unit_test.go index c7d5cf22b..d1e56db2a 100644 --- a/i18n/gi18n/gi18n_z_unit_test.go +++ b/i18n/gi18n/gi18n_z_unit_test.go @@ -85,7 +85,7 @@ func Test_TranslateFormat(t *testing.T) { func Test_DefaultManager(t *testing.T) { gtest.C(t, func(t *gtest.T) { err := gi18n.SetPath(gdebug.TestDataPath("i18n")) - t.Assert(err, nil) + t.AssertNil(err) gi18n.SetLanguage("none") t.Assert(gi18n.T(context.Background(), "{#hello}{#world}"), "{#hello}{#world}") @@ -99,7 +99,7 @@ func Test_DefaultManager(t *testing.T) { gtest.C(t, func(t *gtest.T) { err := gi18n.SetPath(gdebug.CallerDirectory() + gfile.Separator + "testdata" + gfile.Separator + "i18n-dir") - t.Assert(err, nil) + t.AssertNil(err) gi18n.SetLanguage("none") t.Assert(gi18n.Translate(context.Background(), "{#hello}{#world}"), "{#hello}{#world}") @@ -117,7 +117,7 @@ func Test_Instance(t *testing.T) { gtest.C(t, func(t *gtest.T) { m := gi18n.Instance() err := m.SetPath("i18n-dir") - t.Assert(err, nil) + t.AssertNil(err) m.SetLanguage("zh-CN") t.Assert(m.T(context.Background(), "{#hello}{#world}"), "你好世界") }) @@ -141,7 +141,7 @@ func Test_Resource(t *testing.T) { gtest.C(t, func(t *gtest.T) { m := g.I18n("resource") err := m.SetPath("i18n-dir") - t.Assert(err, nil) + t.AssertNil(err) m.SetLanguage("none") t.Assert(m.T(context.Background(), "{#hello}{#world}"), "{#hello}{#world}") diff --git a/net/gclient/gclient_z_unit_test.go b/net/gclient/gclient_z_unit_test.go index 6fcfa5f2e..e9328bca7 100644 --- a/net/gclient/gclient_z_unit_test.go +++ b/net/gclient/gclient_z_unit_test.go @@ -144,7 +144,7 @@ func Test_Client_Cookies(t *testing.T) { c.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p)) resp, err := c.Get(ctx, "/cookie") - t.Assert(err, nil) + t.AssertNil(err) defer resp.Close() t.AssertNE(resp.Header.Get("Set-Cookie"), "") @@ -318,12 +318,12 @@ func Test_Client_File_And_Param(t *testing.T) { s.BindHandler("/", func(r *ghttp.Request) { tmpPath := gfile.Temp(guid.S()) err := gfile.Mkdir(tmpPath) - gtest.Assert(err, nil) + gtest.AssertNil(err) defer gfile.Remove(tmpPath) file := r.GetUploadFile("file") _, err = file.Save(tmpPath) - gtest.Assert(err, nil) + gtest.AssertNil(err) r.Response.Write( r.Get("json"), gfile.GetContents(gfile.Join(tmpPath, gfile.Basename(file.Filename))), @@ -398,7 +398,7 @@ func Test_Client_Middleware(t *testing.T) { }) resp, err := c.Get(ctx, "/") t.Assert(str1, "acefdb") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp.ReadAllString(), str2) t.Assert(isServerHandler, true) @@ -473,7 +473,7 @@ func Test_Client_Request_13_Dump(t *testing.T) { url := fmt.Sprintf("http://127.0.0.1:%d", p) client := g.Client().SetPrefix(url).ContentJson() r, err := client.Post(ctx, "/hello", g.Map{"field": "test_for_request_body"}) - t.Assert(err, nil) + t.AssertNil(err) dumpedText := r.RawRequest() t.Assert(gstr.Contains(dumpedText, "test_for_request_body"), true) dumpedText2 := r.RawResponse() @@ -482,7 +482,7 @@ func Test_Client_Request_13_Dump(t *testing.T) { client2 := g.Client().SetPrefix(url).ContentType("text/html") r2, err := client2.Post(ctx, "/hello2", g.Map{"field": "test_for_request_body"}) - t.Assert(err, nil) + t.AssertNil(err) dumpedText3 := r2.RawRequest() t.Assert(gstr.Contains(dumpedText3, "test_for_request_body"), true) dumpedText4 := r2.RawResponse() @@ -520,15 +520,15 @@ func Test_WebSocketClient(t *testing.T) { client.HandshakeTimeout = time.Minute conn, _, err := client.Dial(fmt.Sprintf("ws://127.0.0.1:%d/ws", p), nil) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() msg := []byte("hello") err = conn.WriteMessage(websocket.TextMessage, msg) - t.Assert(err, nil) + t.AssertNil(err) mt, data, err := conn.ReadMessage() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(mt, websocket.TextMessage) t.Assert(data, msg) }) diff --git a/net/ghttp/ghttp_z_unit_feature_config_test.go b/net/ghttp/ghttp_z_unit_feature_config_test.go index 1aaca1f5f..ff04f7e7e 100644 --- a/net/ghttp/ghttp_z_unit_feature_config_test.go +++ b/net/ghttp/ghttp_z_unit_feature_config_test.go @@ -34,7 +34,7 @@ func Test_ConfigFromMap(t *testing.T) { "cookieHttpOnly": true, } config, err := ghttp.ConfigFromMap(m) - t.Assert(err, nil) + t.AssertNil(err) d1, _ := time.ParseDuration(gconv.String(m["readTimeout"])) d2, _ := time.ParseDuration(gconv.String(m["cookieMaxAge"])) t.Assert(config.Address, m["address"]) @@ -67,7 +67,7 @@ func Test_SetConfigWithMap(t *testing.T) { } s := g.Server() err := s.SetConfigWithMap(m) - t.Assert(err, nil) + t.AssertNil(err) }) } diff --git a/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go b/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go index bc473fa4a..bb3841daa 100644 --- a/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go +++ b/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go @@ -207,7 +207,7 @@ func Test_Middleware_Status(t *testing.T) { resp, err := client.Get(ctx, "/") defer resp.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp.StatusCode, 404) }) } @@ -583,7 +583,7 @@ func Test_Middleware_CORSAndAuth(t *testing.T) { t.Assert(client.PostContent(ctx, "/api.v2/user/list", "token=123456"), "list") // CORS Checks. resp, err := client.Post(ctx, "/api.v2/user/list", "token=123456") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 1) t.Assert(resp.Header["Access-Control-Allow-Headers"][0], "Origin,Content-Type,Accept,User-Agent,Cookie,Authorization,X-Auth-Token,X-Requested-With") t.Assert(resp.Header["Access-Control-Allow-Methods"][0], "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE") diff --git a/net/ghttp/ghttp_z_unit_feature_middleware_cors_test.go b/net/ghttp/ghttp_z_unit_feature_middleware_cors_test.go index d0f4752e7..98d82345e 100644 --- a/net/ghttp/ghttp_z_unit_feature_middleware_cors_test.go +++ b/net/ghttp/ghttp_z_unit_feature_middleware_cors_test.go @@ -38,14 +38,14 @@ func Test_Middleware_CORS1(t *testing.T) { // GET request does not any route. resp, err := client.Get(ctx, "/api.v2/user/list") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 0) t.Assert(resp.StatusCode, 404) resp.Close() // POST request matches the route and CORS middleware. resp, err = client.Post(ctx, "/api.v2/user/list") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 1) t.Assert(resp.Header["Access-Control-Allow-Headers"][0], "Origin,Content-Type,Accept,User-Agent,Cookie,Authorization,X-Auth-Token,X-Requested-With") t.Assert(resp.Header["Access-Control-Allow-Methods"][0], "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE") @@ -59,7 +59,7 @@ func Test_Middleware_CORS1(t *testing.T) { client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) client.SetHeader("Access-Control-Request-Method", "GET") resp, err := client.Options(ctx, "/api.v2/user/list") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 0) t.Assert(resp.ReadAllString(), "Not Found") t.Assert(resp.StatusCode, 404) @@ -71,7 +71,7 @@ func Test_Middleware_CORS1(t *testing.T) { client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) client.SetHeader("Access-Control-Request-Method", "POST") resp, err := client.Options(ctx, "/api.v2/user/list") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 1) t.Assert(resp.StatusCode, 200) resp.Close() @@ -98,7 +98,7 @@ func Test_Middleware_CORS2(t *testing.T) { t.Assert(client.GetContent(ctx, "/api.v2"), "Not Found") // Get request. resp, err := client.Get(ctx, "/api.v2/user/list/1") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 1) t.Assert(resp.Header["Access-Control-Allow-Headers"][0], "Origin,Content-Type,Accept,User-Agent,Cookie,Authorization,X-Auth-Token,X-Requested-With") t.Assert(resp.Header["Access-Control-Allow-Methods"][0], "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE") @@ -113,7 +113,7 @@ func Test_Middleware_CORS2(t *testing.T) { client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) client.SetHeader("Access-Control-Request-Method", "GET") resp, err := client.Options(ctx, "/api.v2/user") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 0) t.Assert(resp.StatusCode, 404) resp.Close() @@ -124,7 +124,7 @@ func Test_Middleware_CORS2(t *testing.T) { client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) client.SetHeader("Access-Control-Request-Method", "GET") resp, err := client.Options(ctx, "/api.v2/user/list/1") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 1) t.Assert(resp.StatusCode, 200) resp.Close() @@ -135,7 +135,7 @@ func Test_Middleware_CORS2(t *testing.T) { client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) client.SetHeader("Access-Control-Request-Method", "POST") resp, err := client.Options(ctx, "/api.v2/user/list/1") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(resp.Header["Access-Control-Allow-Headers"]), 0) t.Assert(resp.StatusCode, 404) resp.Close() diff --git a/net/ghttp/ghttp_z_unit_feature_router_basic_test.go b/net/ghttp/ghttp_z_unit_feature_router_basic_test.go index 72bf276c6..5698edef0 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_basic_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_basic_test.go @@ -115,22 +115,22 @@ func Test_Router_Method(t *testing.T) { resp1, err := client.Get(ctx, "/get") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 200) resp2, err := client.Post(ctx, "/get") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 404) resp3, err := client.Get(ctx, "/post") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 404) resp4, err := client.Post(ctx, "/post") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 200) }) } @@ -187,27 +187,27 @@ func Test_Router_Status(t *testing.T) { resp1, err := client.Get(ctx, "/200") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 200) resp2, err := client.Get(ctx, "/300") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 300) resp3, err := client.Get(ctx, "/400") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 400) resp4, err := client.Get(ctx, "/500") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 500) resp5, err := client.Get(ctx, "/404") defer resp5.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp5.StatusCode, 404) }) } @@ -232,7 +232,7 @@ func Test_Router_CustomStatusHandler(t *testing.T) { t.Assert(client.GetContent(ctx, "/"), "hello") resp, err := client.Get(ctx, "/ThisDoesNotExist") defer resp.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp.StatusCode, 404) t.Assert(resp.ReadAllString(), "404 page") }) @@ -256,7 +256,7 @@ func Test_Router_404(t *testing.T) { t.Assert(client.GetContent(ctx, "/"), "hello") resp, err := client.Get(ctx, "/ThisDoesNotExist") defer resp.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp.StatusCode, 404) }) } diff --git a/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go b/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go index c8c00d908..a9af14ea2 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go @@ -87,22 +87,22 @@ func Test_Router_DomainMethod(t *testing.T) { resp1, err := client.Get(ctx, "/get") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 404) resp2, err := client.Post(ctx, "/get") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 404) resp3, err := client.Get(ctx, "/post") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 404) resp4, err := client.Post(ctx, "/post") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 404) }) @@ -112,22 +112,22 @@ func Test_Router_DomainMethod(t *testing.T) { resp1, err := client.Get(ctx, "/get") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 200) resp2, err := client.Post(ctx, "/get") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 404) resp3, err := client.Get(ctx, "/post") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 404) resp4, err := client.Post(ctx, "/post") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 200) }) @@ -137,22 +137,22 @@ func Test_Router_DomainMethod(t *testing.T) { resp1, err := client.Get(ctx, "/get") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 200) resp2, err := client.Post(ctx, "/get") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 404) resp3, err := client.Get(ctx, "/post") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 404) resp4, err := client.Post(ctx, "/post") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 200) }) } @@ -183,22 +183,22 @@ func Test_Router_DomainStatus(t *testing.T) { resp1, err := client.Get(ctx, "/200") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 404) resp2, err := client.Get(ctx, "/300") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 404) resp3, err := client.Get(ctx, "/400") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 404) resp4, err := client.Get(ctx, "/500") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 404) }) gtest.C(t, func(t *gtest.T) { @@ -207,22 +207,22 @@ func Test_Router_DomainStatus(t *testing.T) { resp1, err := client.Get(ctx, "/200") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 200) resp2, err := client.Get(ctx, "/300") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 300) resp3, err := client.Get(ctx, "/400") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 400) resp4, err := client.Get(ctx, "/500") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 500) }) gtest.C(t, func(t *gtest.T) { @@ -231,22 +231,22 @@ func Test_Router_DomainStatus(t *testing.T) { resp1, err := client.Get(ctx, "/200") defer resp1.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.StatusCode, 200) resp2, err := client.Get(ctx, "/300") defer resp2.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.StatusCode, 300) resp3, err := client.Get(ctx, "/400") defer resp3.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp3.StatusCode, 400) resp4, err := client.Get(ctx, "/500") defer resp4.Close() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.StatusCode, 500) }) } diff --git a/net/ghttp/ghttp_z_unit_feature_router_domain_object_rest_test.go b/net/ghttp/ghttp_z_unit_feature_router_domain_object_rest_test.go index 6b30f82a8..a8f6cb1c2 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_domain_object_rest_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_domain_object_rest_test.go @@ -78,7 +78,7 @@ func Test_Router_DomainObjectRest(t *testing.T) { if err == nil { defer resp1.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.Header.Get("head-ok"), "") t.Assert(client.GetContent(ctx, "/none-exist"), "Not Found") }) @@ -96,7 +96,7 @@ func Test_Router_DomainObjectRest(t *testing.T) { if err == nil { defer resp1.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.Header.Get("head-ok"), "1") t.Assert(client.GetContent(ctx, "/none-exist"), "Not Found") }) @@ -114,7 +114,7 @@ func Test_Router_DomainObjectRest(t *testing.T) { if err == nil { defer resp1.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.Header.Get("head-ok"), "1") t.Assert(client.GetContent(ctx, "/none-exist"), "Not Found") }) diff --git a/net/ghttp/ghttp_z_unit_feature_router_group_rest_test.go b/net/ghttp/ghttp_z_unit_feature_router_group_rest_test.go index b46c64cc0..ca47cac70 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_group_rest_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_group_rest_test.go @@ -80,7 +80,7 @@ func Test_Router_GroupRest1(t *testing.T) { if err == nil { defer resp2.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.Header.Get("head-ok"), "1") t.Assert(client.GetContent(ctx, "/api/group-obj-rest"), "Not Found") @@ -94,7 +94,7 @@ func Test_Router_GroupRest1(t *testing.T) { if err == nil { defer resp4.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.Header.Get("head-ok"), "1") }) } @@ -125,7 +125,7 @@ func Test_Router_GroupRest2(t *testing.T) { if err == nil { defer resp2.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.Header.Get("head-ok"), "1") t.Assert(client.GetContent(ctx, "/api/group-obj-rest"), "Not Found") @@ -139,7 +139,7 @@ func Test_Router_GroupRest2(t *testing.T) { if err == nil { defer resp4.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp4.Header.Get("head-ok"), "1") }) } diff --git a/net/ghttp/ghttp_z_unit_feature_router_object_rest1_test.go b/net/ghttp/ghttp_z_unit_feature_router_object_rest1_test.go index 840ddbb94..32d5ec7d1 100644 --- a/net/ghttp/ghttp_z_unit_feature_router_object_rest1_test.go +++ b/net/ghttp/ghttp_z_unit_feature_router_object_rest1_test.go @@ -78,7 +78,7 @@ func Test_Router_ObjectRest(t *testing.T) { if err == nil { defer resp1.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp1.Header.Get("head-ok"), "1") t.Assert(client.GetContent(ctx, "/object-rest/get"), "1Object Get2") @@ -91,7 +91,7 @@ func Test_Router_ObjectRest(t *testing.T) { if err == nil { defer resp2.Close() } - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resp2.Header.Get("head-ok"), "1") t.Assert(client.GetContent(ctx, "/none-exist"), "Not Found") diff --git a/net/ghttp/ghttp_z_unit_feature_session_test.go b/net/ghttp/ghttp_z_unit_feature_session_test.go index 59fe356dc..e76187848 100644 --- a/net/ghttp/ghttp_z_unit_feature_session_test.go +++ b/net/ghttp/ghttp_z_unit_feature_session_test.go @@ -179,7 +179,7 @@ func Test_Session_Custom_Id(t *testing.T) { client := g.Client() client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())) r, err := client.Get(ctx, "/id") - t.Assert(err, nil) + t.AssertNil(err) defer r.Close() t.Assert(r.ReadAllString(), sessionId) t.Assert(r.GetCookie(s.GetSessionIdName()), sessionId) diff --git a/net/ghttp/ghttp_z_unit_feature_template_test.go b/net/ghttp/ghttp_z_unit_feature_template_test.go index 8a3ee07b1..8c41f443f 100644 --- a/net/ghttp/ghttp_z_unit_feature_template_test.go +++ b/net/ghttp/ghttp_z_unit_feature_template_test.go @@ -31,7 +31,7 @@ func Test_Template_Basic(t *testing.T) { err := r.Response.WriteTpl("index.html", g.Map{ "name": "john", }) - t.Assert(err, nil) + t.AssertNil(err) }) s.SetDumpRouterMap(false) s.Start() @@ -55,7 +55,7 @@ func Test_Template_Encode(t *testing.T) { err := r.Response.WriteTpl("index.html", g.Map{ "name": "john", }) - t.Assert(err, nil) + t.AssertNil(err) }) s.SetDumpRouterMap(false) s.Start() @@ -78,11 +78,11 @@ func Test_Template_Layout1(t *testing.T) { err := r.Response.WriteTpl("layout.html", g.Map{ "mainTpl": "main/main1.html", }) - t.Assert(err, nil) + t.AssertNil(err) }) s.BindHandler("/nil", func(r *ghttp.Request) { err := r.Response.WriteTpl("layout.html", nil) - t.Assert(err, nil) + t.AssertNil(err) }) s.SetDumpRouterMap(false) s.Start() @@ -106,17 +106,17 @@ func Test_Template_Layout2(t *testing.T) { err := r.Response.WriteTpl("layout.html", g.Map{ "mainTpl": "main/main1.html", }) - t.Assert(err, nil) + t.AssertNil(err) }) s.BindHandler("/main2", func(r *ghttp.Request) { err := r.Response.WriteTpl("layout.html", g.Map{ "mainTpl": "main/main2.html", }) - t.Assert(err, nil) + t.AssertNil(err) }) s.BindHandler("/nil", func(r *ghttp.Request) { err := r.Response.WriteTpl("layout.html", nil) - t.Assert(err, nil) + t.AssertNil(err) }) s.SetDumpRouterMap(false) s.Start() @@ -137,7 +137,7 @@ func Test_Template_BuildInVarRequest(t *testing.T) { s := g.Server(guid.S()) s.BindHandler("/:table/test", func(r *ghttp.Request) { err := r.Response.WriteTplContent("{{.Request.table}}") - t.Assert(err, nil) + t.AssertNil(err) }) s.SetDumpRouterMap(false) s.Start() @@ -162,7 +162,7 @@ func Test_Template_XSS(t *testing.T) { err := r.Response.WriteTplContent("{{if eq 1 1}}{{.v}}{{end}}", g.Map{ "v": c, }) - t.Assert(err, nil) + t.AssertNil(err) }) s.SetDumpRouterMap(false) s.Start() diff --git a/net/ghttp/ghttp_z_unit_feature_websocket_test.go b/net/ghttp/ghttp_z_unit_feature_websocket_test.go index 5887100b6..916291eda 100644 --- a/net/ghttp/ghttp_z_unit_feature_websocket_test.go +++ b/net/ghttp/ghttp_z_unit_feature_websocket_test.go @@ -44,15 +44,15 @@ func Test_WebSocket(t *testing.T) { conn, _, err := websocket.DefaultDialer.Dial(fmt.Sprintf( "ws://127.0.0.1:%d/ws", s.GetListenedPort(), ), nil) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() msg := []byte("hello") err = conn.WriteMessage(websocket.TextMessage, msg) - t.Assert(err, nil) + t.AssertNil(err) mt, data, err := conn.ReadMessage() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(mt, websocket.TextMessage) t.Assert(data, msg) }) diff --git a/net/gtcp/gtcp_z_unit_conn_pkg_test.go b/net/gtcp/gtcp_z_unit_conn_pkg_test.go index 71ce6938a..8d216ade4 100644 --- a/net/gtcp/gtcp_z_unit_conn_pkg_test.go +++ b/net/gtcp/gtcp_z_unit_conn_pkg_test.go @@ -34,21 +34,21 @@ func Test_Package_Basic(t *testing.T) { // SendPkg gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() for i := 0; i < 100; i++ { err := conn.SendPkg([]byte(gconv.String(i))) - t.Assert(err, nil) + t.AssertNil(err) } for i := 0; i < 100; i++ { err := conn.SendPkgWithTimeout([]byte(gconv.String(i)), time.Second) - t.Assert(err, nil) + t.AssertNil(err) } }) // SendPkg with big data - failure. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 65536) err = conn.SendPkg(data) @@ -57,25 +57,25 @@ func Test_Package_Basic(t *testing.T) { // SendRecvPkg gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() for i := 100; i < 200; i++ { data := []byte(gconv.String(i)) result, err := conn.SendRecvPkg(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) } for i := 100; i < 200; i++ { data := []byte(gconv.String(i)) result, err := conn.SendRecvPkgWithTimeout(data, time.Second) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) } }) // SendRecvPkg with big data - failure. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 65536) result, err := conn.SendRecvPkg(data) @@ -85,13 +85,13 @@ func Test_Package_Basic(t *testing.T) { // SendRecvPkg with big data - success. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 65500) data[100] = byte(65) data[65400] = byte(85) result, err := conn.SendRecvPkg(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) }) } @@ -114,7 +114,7 @@ func Test_Package_Timeout(t *testing.T) { time.Sleep(100 * time.Millisecond) gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := []byte("10000") result, err := conn.SendRecvPkgWithTimeout(data, time.Millisecond*500) @@ -123,11 +123,11 @@ func Test_Package_Timeout(t *testing.T) { }) gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := []byte("10000") result, err := conn.SendRecvPkgWithTimeout(data, time.Second*2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) }) } @@ -151,7 +151,7 @@ func Test_Package_Option(t *testing.T) { // SendRecvPkg with big data - failure. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 0xFF+1) result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 1}) @@ -161,13 +161,13 @@ func Test_Package_Option(t *testing.T) { // SendRecvPkg with big data - success. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 0xFF) data[100] = byte(65) data[200] = byte(85) result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 1}) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) }) } diff --git a/net/gtcp/gtcp_z_unit_pool_pkg_test.go b/net/gtcp/gtcp_z_unit_pool_pkg_test.go index 4a0a8a86f..54df536aa 100644 --- a/net/gtcp/gtcp_z_unit_pool_pkg_test.go +++ b/net/gtcp/gtcp_z_unit_pool_pkg_test.go @@ -34,21 +34,21 @@ func Test_Pool_Package_Basic(t *testing.T) { // SendPkg gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() for i := 0; i < 100; i++ { err := conn.SendPkg([]byte(gconv.String(i))) - t.Assert(err, nil) + t.AssertNil(err) } for i := 0; i < 100; i++ { err := conn.SendPkgWithTimeout([]byte(gconv.String(i)), time.Second) - t.Assert(err, nil) + t.AssertNil(err) } }) // SendPkg with big data - failure. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 65536) err = conn.SendPkg(data) @@ -57,25 +57,25 @@ func Test_Pool_Package_Basic(t *testing.T) { // SendRecvPkg gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() for i := 100; i < 200; i++ { data := []byte(gconv.String(i)) result, err := conn.SendRecvPkg(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) } for i := 100; i < 200; i++ { data := []byte(gconv.String(i)) result, err := conn.SendRecvPkgWithTimeout(data, time.Second) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) } }) // SendRecvPkg with big data - failure. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 65536) result, err := conn.SendRecvPkg(data) @@ -85,13 +85,13 @@ func Test_Pool_Package_Basic(t *testing.T) { // SendRecvPkg with big data - success. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 65500) data[100] = byte(65) data[65400] = byte(85) result, err := conn.SendRecvPkg(data) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) }) } @@ -114,7 +114,7 @@ func Test_Pool_Package_Timeout(t *testing.T) { time.Sleep(100 * time.Millisecond) gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := []byte("10000") result, err := conn.SendRecvPkgWithTimeout(data, time.Millisecond*500) @@ -123,11 +123,11 @@ func Test_Pool_Package_Timeout(t *testing.T) { }) gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := []byte("10000") result, err := conn.SendRecvPkgWithTimeout(data, time.Second*2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) }) } @@ -151,7 +151,7 @@ func Test_Pool_Package_Option(t *testing.T) { // SendRecvPkg with big data - failure. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 0xFF+1) result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 1}) @@ -161,13 +161,13 @@ func Test_Pool_Package_Option(t *testing.T) { // SendRecvPkg with big data - success. gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := make([]byte, 0xFF) data[100] = byte(65) data[200] = byte(85) result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 1}) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, data) }) } diff --git a/net/gtcp/gtcp_z_unit_pool_test.go b/net/gtcp/gtcp_z_unit_pool_test.go index 7b3544328..6eae0bf44 100644 --- a/net/gtcp/gtcp_z_unit_pool_test.go +++ b/net/gtcp/gtcp_z_unit_pool_test.go @@ -32,13 +32,13 @@ func Test_Pool_Basic1(t *testing.T) { time.Sleep(100 * time.Millisecond) gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := []byte("9999") err = conn.SendPkg(data) - t.Assert(err, nil) + t.AssertNil(err) err = conn.SendPkgWithTimeout(data, time.Second) - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -52,13 +52,13 @@ func Test_Pool_Basic2(t *testing.T) { time.Sleep(100 * time.Millisecond) gtest.C(t, func(t *gtest.T) { conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) defer conn.Close() data := []byte("9999") err = conn.SendPkg(data) - t.Assert(err, nil) + t.AssertNil(err) //err = conn.SendPkgWithTimeout(data, time.Second) - //t.Assert(err, nil) + //t.AssertNil(err) _, err = conn.SendRecv(data, -1) t.AssertNE(err, nil) diff --git a/net/gudp/gudp_z_unit_test.go b/net/gudp/gudp_z_unit_test.go index 7b1154d02..55d6f6e85 100644 --- a/net/gudp/gudp_z_unit_test.go +++ b/net/gudp/gudp_z_unit_test.go @@ -44,7 +44,7 @@ func Test_Basic(t *testing.T) { gtest.C(t, func(t *gtest.T) { for i := 0; i < 100; i++ { conn, err := gudp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(conn.Send([]byte(gconv.String(i))), nil) conn.Close() } @@ -53,9 +53,9 @@ func Test_Basic(t *testing.T) { gtest.C(t, func(t *gtest.T) { for i := 0; i < 100; i++ { conn, err := gudp.NewConn(fmt.Sprintf("127.0.0.1:%d", p)) - t.Assert(err, nil) + t.AssertNil(err) _, err = conn.SendRecv([]byte(gconv.String(i)), -1) - t.Assert(err, nil) + t.AssertNil(err) //t.Assert(string(result), fmt.Sprintf(`> %d`, i)) conn.Close() } @@ -64,14 +64,14 @@ func Test_Basic(t *testing.T) { gtest.C(t, func(t *gtest.T) { for i := 0; i < 100; i++ { err := gudp.Send(fmt.Sprintf("127.0.0.1:%d", p), []byte(gconv.String(i))) - t.Assert(err, nil) + t.AssertNil(err) } }) // gudp.SendRecv gtest.C(t, func(t *gtest.T) { for i := 0; i < 100; i++ { result, err := gudp.SendRecv(fmt.Sprintf("127.0.0.1:%d", p), []byte(gconv.String(i)), -1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(result), fmt.Sprintf(`> %d`, i)) } }) @@ -103,12 +103,12 @@ func Test_Buffer(t *testing.T) { time.Sleep(100 * time.Millisecond) gtest.C(t, func(t *gtest.T) { result, err := gudp.SendRecv(fmt.Sprintf("127.0.0.1:%d", p), []byte("123"), -1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(result), "1") }) gtest.C(t, func(t *gtest.T) { result, err := gudp.SendRecv(fmt.Sprintf("127.0.0.1:%d", p), []byte("456"), -1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(result), "4") }) } diff --git a/os/gcfg/gcfg_z_unit_basic_test.go b/os/gcfg/gcfg_z_unit_basic_test.go index 67ecbe29e..ff0347660 100644 --- a/os/gcfg/gcfg_z_unit_basic_test.go +++ b/os/gcfg/gcfg_z_unit_basic_test.go @@ -105,7 +105,7 @@ func Test_SetFileName(t *testing.T) { gtest.C(t, func(t *gtest.T) { path := "config.json" err := gfile.PutContents(path, config) - t.Assert(err, nil) + t.AssertNil(err) defer func() { _ = gfile.Remove(path) }() @@ -155,18 +155,18 @@ func TestCfg_Get_WrongConfigFile(t *testing.T) { var err error configPath := gfile.Temp(gtime.TimestampNanoStr()) err = gfile.Mkdir(configPath) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(configPath) defer gfile.Chdir(gfile.Pwd()) err = gfile.Chdir(configPath) - t.Assert(err, nil) + t.AssertNil(err) err = gfile.PutContents( gfile.Join(configPath, "config.yml"), "wrong config", ) - t.Assert(err, nil) + t.AssertNil(err) adapterFile, err := gcfg.NewAdapterFile("config.yml") t.AssertNil(err) diff --git a/os/gcmd/gcmd_z_unit_parser_test.go b/os/gcmd/gcmd_z_unit_parser_test.go index 2b7699f68..5a9307d01 100644 --- a/os/gcmd/gcmd_z_unit_parser_test.go +++ b/os/gcmd/gcmd_z_unit_parser_test.go @@ -25,7 +25,7 @@ func Test_Parse(t *testing.T) { "f,force": false, "q,quiet": false, }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(p.GetArgAll()), 3) t.Assert(p.GetArg(0), "gf") t.Assert(p.GetArg(1), "remove") @@ -64,7 +64,7 @@ func Test_ParseArgs(t *testing.T) { "f,force": false, "q,quiet": false, }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(p.GetArgAll()), 3) t.Assert(p.GetArg(0), "gf") t.Assert(p.GetArg(1), "remove") diff --git a/os/genv/genv_z_unit_test.go b/os/genv/genv_z_unit_test.go index ccdc9e5b7..b1b23e64c 100644 --- a/os/genv/genv_z_unit_test.go +++ b/os/genv/genv_z_unit_test.go @@ -29,7 +29,7 @@ func Test_GEnv_Map(t *testing.T) { value := gconv.String(gtime.TimestampNano()) key := "TEST_ENV_" + value err := os.Setenv(key, "TEST") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(genv.Map()[key], "TEST") }) } @@ -39,7 +39,7 @@ func Test_GEnv_Get(t *testing.T) { value := gconv.String(gtime.TimestampNano()) key := "TEST_ENV_" + value err := os.Setenv(key, "TEST") - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(genv.Get(key).String(), "TEST") }) } @@ -49,7 +49,7 @@ func Test_GEnv_GetVar(t *testing.T) { value := gconv.String(gtime.TimestampNano()) key := "TEST_ENV_" + value err := os.Setenv(key, "TEST") - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(genv.Get(key).String(), "TEST") }) } @@ -59,7 +59,7 @@ func Test_GEnv_Contains(t *testing.T) { value := gconv.String(gtime.TimestampNano()) key := "TEST_ENV_" + value err := os.Setenv(key, "TEST") - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(genv.Contains(key), true) t.AssertEQ(genv.Contains("none"), false) }) @@ -70,7 +70,7 @@ func Test_GEnv_Set(t *testing.T) { value := gconv.String(gtime.TimestampNano()) key := "TEST_ENV_" + value err := genv.Set(key, "TEST") - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(os.Getenv(key), "TEST") }) } @@ -81,7 +81,7 @@ func Test_GEnv_SetMap(t *testing.T) { "K1": "TEST1", "K2": "TEST2", }) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(os.Getenv("K1"), "TEST1") t.AssertEQ(os.Getenv("K2"), "TEST2") }) @@ -102,9 +102,9 @@ func Test_GEnv_Remove(t *testing.T) { value := gconv.String(gtime.TimestampNano()) key := "TEST_ENV_" + value err := os.Setenv(key, "TEST") - t.Assert(err, nil) + t.AssertNil(err) err = genv.Remove(key) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(os.Getenv(key), "") }) } diff --git a/os/gfile/gfile_z_unit_contents_test.go b/os/gfile/gfile_z_unit_contents_test.go index bb9b01da3..684af97cf 100644 --- a/os/gfile/gfile_z_unit_contents_test.go +++ b/os/gfile/gfile_z_unit_contents_test.go @@ -100,10 +100,10 @@ func Test_Truncate(t *testing.T) { createTestFile(filepaths1, "abcdefghijkmln") defer delTestFiles(filepaths1) err = gfile.Truncate(testpath()+filepaths1, 10) - t.Assert(err, nil) + t.AssertNil(err) files, err = os.Open(testpath() + filepaths1) - t.Assert(err, nil) + t.AssertNil(err) defer files.Close() fileinfo, err2 := files.Stat() t.Assert(err2, nil) @@ -126,10 +126,10 @@ func Test_PutContents(t *testing.T) { defer delTestFiles(filepaths) err = gfile.PutContents(testpath()+filepaths, "test!") - t.Assert(err, nil) + t.AssertNil(err) readcontent, err = ioutil.ReadFile(testpath() + filepaths) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(readcontent), "test!") err = gfile.PutContents("", "test!") @@ -149,10 +149,10 @@ func Test_PutContentsAppend(t *testing.T) { createTestFile(filepaths, "a") defer delTestFiles(filepaths) err = gfile.PutContentsAppend(testpath()+filepaths, "hello") - t.Assert(err, nil) + t.AssertNil(err) readcontent, err = ioutil.ReadFile(testpath() + filepaths) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(readcontent), "ahello") err = gfile.PutContentsAppend("", "hello") @@ -173,10 +173,10 @@ func Test_PutBinContents(t *testing.T) { defer delTestFiles(filepaths) err = gfile.PutBytes(testpath()+filepaths, []byte("test!!")) - t.Assert(err, nil) + t.AssertNil(err) readcontent, err = ioutil.ReadFile(testpath() + filepaths) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(readcontent), "test!!") err = gfile.PutBytes("", []byte("test!!")) @@ -195,10 +195,10 @@ func Test_PutBinContentsAppend(t *testing.T) { createTestFile(filepaths, "test!!") defer delTestFiles(filepaths) err = gfile.PutBytesAppend(testpath()+filepaths, []byte("word")) - t.Assert(err, nil) + t.AssertNil(err) readcontent, err = ioutil.ReadFile(testpath() + filepaths) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(readcontent), "test!!word") err = gfile.PutBytesAppend("", []byte("word")) @@ -324,7 +324,7 @@ func Test_Home(t *testing.T) { ) reads, err = gfile.Home("a", "b") - t.Assert(err, nil) + t.AssertNil(err) t.AssertNE(reads, "") }) } diff --git a/os/gfile/gfile_z_unit_copy_test.go b/os/gfile/gfile_z_unit_copy_test.go index 6a00895fa..13557933d 100644 --- a/os/gfile/gfile_z_unit_copy_test.go +++ b/os/gfile/gfile_z_unit_copy_test.go @@ -127,7 +127,7 @@ func Test_CopyDir(t *testing.T) { t.Assert(gfile.GetContents(dst), dstContent) err := gfile.CopyDir(gfile.Dir(src), gfile.Dir(dst)) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.GetContents(src), srcContent) t.Assert(gfile.GetContents(dst), srcContent) diff --git a/os/gfile/gfile_z_unit_scan_test.go b/os/gfile/gfile_z_unit_scan_test.go index c64ec62c0..42e80faf5 100644 --- a/os/gfile/gfile_z_unit_scan_test.go +++ b/os/gfile/gfile_z_unit_scan_test.go @@ -19,14 +19,14 @@ func Test_ScanDir(t *testing.T) { teatPath := gdebug.TestDataPath() gtest.C(t, func(t *gtest.T) { files, err := gfile.ScanDir(teatPath, "*", false) - t.Assert(err, nil) + t.AssertNil(err) t.AssertIN(teatPath+gfile.Separator+"dir1", files) t.AssertIN(teatPath+gfile.Separator+"dir2", files) t.AssertNE(teatPath+gfile.Separator+"dir1"+gfile.Separator+"file1", files) }) gtest.C(t, func(t *gtest.T) { files, err := gfile.ScanDir(teatPath, "*", true) - t.Assert(err, nil) + t.AssertNil(err) t.AssertIN(teatPath+gfile.Separator+"dir1", files) t.AssertIN(teatPath+gfile.Separator+"dir2", files) t.AssertIN(teatPath+gfile.Separator+"dir1"+gfile.Separator+"file1", files) @@ -43,7 +43,7 @@ func Test_ScanDirFunc(t *testing.T) { } return path }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 1) t.Assert(gfile.Name(files[0]), "file1") }) @@ -53,12 +53,12 @@ func Test_ScanDirFile(t *testing.T) { teatPath := gdebug.TestDataPath() gtest.C(t, func(t *gtest.T) { files, err := gfile.ScanDirFile(teatPath, "*", false) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 0) }) gtest.C(t, func(t *gtest.T) { files, err := gfile.ScanDirFile(teatPath, "*", true) - t.Assert(err, nil) + t.AssertNil(err) t.AssertNI(teatPath+gfile.Separator+"dir1", files) t.AssertNI(teatPath+gfile.Separator+"dir2", files) t.AssertIN(teatPath+gfile.Separator+"dir1"+gfile.Separator+"file1", files) @@ -74,7 +74,7 @@ func Test_ScanDirFileFunc(t *testing.T) { array.Append(1) return path }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 0) t.Assert(array.Len(), 0) }) @@ -87,7 +87,7 @@ func Test_ScanDirFileFunc(t *testing.T) { } return "" }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 1) t.Assert(array.Len(), 3) }) diff --git a/os/gfile/gfile_z_unit_search_test.go b/os/gfile/gfile_z_unit_search_test.go index 6a93d34a0..527abec5f 100644 --- a/os/gfile/gfile_z_unit_search_test.go +++ b/os/gfile/gfile_z_unit_search_test.go @@ -31,13 +31,13 @@ func Test_Search(t *testing.T) { ypaths1 = paths1 tpath, err = gfile.Search(testpath() + paths1) - t.Assert(err, nil) + t.AssertNil(err) tpath = filepath.ToSlash(tpath) // 自定义优先路径 tpath2, err = gfile.Search(testpath() + paths1) - t.Assert(err, nil) + t.AssertNil(err) tpath2 = filepath.ToSlash(tpath2) tempstr = testpath() diff --git a/os/gfile/gfile_z_unit_test.go b/os/gfile/gfile_z_unit_test.go index e290621e7..58f939069 100644 --- a/os/gfile/gfile_z_unit_test.go +++ b/os/gfile/gfile_z_unit_test.go @@ -69,7 +69,7 @@ func Test_Create(t *testing.T) { fileobj, err = gfile.Create(testpath() + v) defer delTestFiles(v) fileobj.Close() - t.Assert(err, nil) + t.AssertNil(err) } }) } @@ -97,7 +97,7 @@ func Test_Open(t *testing.T) { fileobj, err = gfile.Open(testpath() + v) fileobj.Close() if flags[k] { - t.Assert(err, nil) + t.AssertNil(err) } else { t.AssertNE(err, nil) } @@ -130,7 +130,7 @@ func Test_OpenFile(t *testing.T) { fileobj, err = gfile.OpenFile(testpath()+v, os.O_RDWR, 0666) fileobj.Close() if flags[k] { - t.Assert(err, nil) + t.AssertNil(err) } else { t.AssertNE(err, nil) } @@ -162,7 +162,7 @@ func Test_OpenWithFlag(t *testing.T) { fileobj, err = gfile.OpenWithFlag(testpath()+v, os.O_RDWR) fileobj.Close() if flags[k] { - t.Assert(err, nil) + t.AssertNil(err) } else { t.AssertNE(err, nil) } @@ -193,7 +193,7 @@ func Test_OpenWithFlagPerm(t *testing.T) { fileobj, err = gfile.OpenWithFlagPerm(testpath()+v, os.O_RDWR, 0666) fileobj.Close() if flags[k] { - t.Assert(err, nil) + t.AssertNil(err) } else { t.AssertNE(err, nil) } @@ -238,7 +238,7 @@ func Test_Exists(t *testing.T) { func Test_Pwd(t *testing.T) { gtest.C(t, func(t *gtest.T) { paths, err := os.Getwd() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.Pwd(), paths) }) @@ -292,10 +292,10 @@ func Test_Info(t *testing.T) { createTestFile(paths, "") defer delTestFiles(paths) files, err = gfile.Stat(testpath() + paths) - t.Assert(err, nil) + t.AssertNil(err) files2, err = os.Stat(testpath() + paths) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(files, files2) @@ -370,7 +370,7 @@ func Test_DirNames(t *testing.T) { readlist, err = gfile.DirNames(testpath() + paths) - t.Assert(err, nil) + t.AssertNil(err) t.AssertIN(readlist, havelist) _, err = gfile.DirNames("") @@ -406,16 +406,16 @@ func Test_Glob(t *testing.T) { defer delTestFiles(dirpath) resultlist, err = gfile.Glob(testpath()+paths, true) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(resultlist, havelist1) resultlist, err = gfile.Glob(testpath()+paths, false) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(formatpaths(resultlist), formatpaths(havelist2)) _, err = gfile.Glob("", true) - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -628,13 +628,13 @@ func Test_Mkdir(t *testing.T) { defer delTestFiles("/testfile") err = gfile.Mkdir(testpath() + tpath) - t.Assert(err, nil) + t.AssertNil(err) err = gfile.Mkdir("") t.AssertNE(err, nil) err = gfile.Mkdir(testpath() + tpath + "2/t1") - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -652,7 +652,7 @@ func Test_Stat(t *testing.T) { defer delTestFiles(tpath1) fileiofo, err = gfile.Stat(testpath() + tpath1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(fileiofo.Size(), 1) diff --git a/os/gfile/gfile_z_unit_time_test.go b/os/gfile/gfile_z_unit_time_test.go index bb22bf8a1..fb83d1faa 100644 --- a/os/gfile/gfile_z_unit_time_test.go +++ b/os/gfile/gfile_z_unit_time_test.go @@ -27,7 +27,7 @@ func Test_MTime(t *testing.T) { createTestFile(file1, "") defer delTestFiles(file1) fileobj, err = os.Stat(testpath() + file1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gfile.MTime(testpath()+file1), fileobj.ModTime()) t.Assert(gfile.MTime(""), "") @@ -45,7 +45,7 @@ func Test_MTimeMillisecond(t *testing.T) { createTestFile(file1, "") defer delTestFiles(file1) fileobj, err = os.Stat(testpath() + file1) - t.Assert(err, nil) + t.AssertNil(err) time.Sleep(time.Millisecond * 100) t.AssertGE( diff --git a/os/gfpool/gfpool_z_unit_test.go b/os/gfpool/gfpool_z_unit_test.go index 6ea9df9f0..6960d668c 100644 --- a/os/gfpool/gfpool_z_unit_test.go +++ b/os/gfpool/gfpool_z_unit_test.go @@ -150,29 +150,29 @@ func Test_ConcurrentOS(t *testing.T) { path := gfile.Temp(gtime.TimestampNanoStr()) defer gfile.Remove(path) f1, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f1.Close() f2, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f2.Close() for i := 0; i < 100; i++ { _, err = f1.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } for i := 0; i < 100; i++ { _, err = f2.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } for i := 0; i < 1000; i++ { _, err = f1.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } for i := 0; i < 1000; i++ { _, err = f2.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } t.Assert(gstr.Count(gfile.GetContents(path), "@1234567890#"), 2200) }) @@ -181,20 +181,20 @@ func Test_ConcurrentOS(t *testing.T) { path := gfile.Temp(gtime.TimestampNanoStr()) defer gfile.Remove(path) f1, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f1.Close() f2, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f2.Close() for i := 0; i < 1000; i++ { _, err = f1.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } for i := 0; i < 1000; i++ { _, err = f2.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } t.Assert(gstr.Count(gfile.GetContents(path), "@1234567890#"), 2000) }) @@ -202,11 +202,11 @@ func Test_ConcurrentOS(t *testing.T) { path := gfile.Temp(gtime.TimestampNanoStr()) defer gfile.Remove(path) f1, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f1.Close() f2, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f2.Close() s1 := "" @@ -214,14 +214,14 @@ func Test_ConcurrentOS(t *testing.T) { s1 += "@1234567890#" } _, err = f2.Write([]byte(s1)) - t.Assert(err, nil) + t.AssertNil(err) s2 := "" for i := 0; i < 1000; i++ { s2 += "@1234567890#" } _, err = f2.Write([]byte(s2)) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gstr.Count(gfile.GetContents(path), "@1234567890#"), 2000) }) @@ -230,11 +230,11 @@ func Test_ConcurrentOS(t *testing.T) { // path := gfile.Temp(gtime.TimestampNanoStr()) // defer gfile.Remove(path) // f1, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - // t.Assert(err, nil) + // t.AssertNil(err) // defer f1.Close() // // f2, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - // t.Assert(err, nil) + // t.AssertNil(err) // defer f2.Close() // // wg := sync.WaitGroup{} @@ -245,7 +245,7 @@ func Test_ConcurrentOS(t *testing.T) { // defer wg.Done() // <-ch // _, err = f1.Write([]byte("@1234567890#")) - // t.Assert(err, nil) + // t.AssertNil(err) // }() // } // for i := 0; i < 1000; i++ { @@ -254,7 +254,7 @@ func Test_ConcurrentOS(t *testing.T) { // defer wg.Done() // <-ch // _, err = f2.Write([]byte("@1234567890#")) - // t.Assert(err, nil) + // t.AssertNil(err) // }() // } // close(ch) @@ -268,20 +268,20 @@ func Test_ConcurrentGFPool(t *testing.T) { path := gfile.Temp(gtime.TimestampNanoStr()) defer gfile.Remove(path) f1, err := gfpool.Open(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f1.Close() f2, err := gfpool.Open(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - t.Assert(err, nil) + t.AssertNil(err) defer f2.Close() for i := 0; i < 1000; i++ { _, err = f1.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } for i := 0; i < 1000; i++ { _, err = f2.Write([]byte("@1234567890#")) - t.Assert(err, nil) + t.AssertNil(err) } t.Assert(gstr.Count(gfile.GetContents(path), "@1234567890#"), 2000) }) @@ -290,11 +290,11 @@ func Test_ConcurrentGFPool(t *testing.T) { // path := gfile.Temp(gtime.TimestampNanoStr()) // defer gfile.Remove(path) // f1, err := gfpool.Open(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - // t.Assert(err, nil) + // t.AssertNil(err) // defer f1.Close() // // f2, err := gfpool.Open(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_APPEND, 0666) - // t.Assert(err, nil) + // t.AssertNil(err) // defer f2.Close() // // wg := sync.WaitGroup{} @@ -305,7 +305,7 @@ func Test_ConcurrentGFPool(t *testing.T) { // defer wg.Done() // <-ch // _, err = f1.Write([]byte("@1234567890#")) - // t.Assert(err, nil) + // t.AssertNil(err) // }() // } // for i := 0; i < 1000; i++ { @@ -314,7 +314,7 @@ func Test_ConcurrentGFPool(t *testing.T) { // defer wg.Done() // <-ch // _, err = f2.Write([]byte("@1234567890#")) - // t.Assert(err, nil) + // t.AssertNil(err) // }() // } // close(ch) diff --git a/os/gfsnotify/gfsnotify_z_unit_test.go b/os/gfsnotify/gfsnotify_z_unit_test.go index d72530b33..0cab0a6b0 100644 --- a/os/gfsnotify/gfsnotify_z_unit_test.go +++ b/os/gfsnotify/gfsnotify_z_unit_test.go @@ -24,31 +24,31 @@ func TestWatcher_AddOnce(t *testing.T) { value := gtype.New() path := gfile.Temp(gconv.String(gtime.TimestampNano())) err := gfile.PutContents(path, "init") - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) time.Sleep(100 * time.Millisecond) callback1, err := gfsnotify.AddOnce("mywatch", path, func(event *gfsnotify.Event) { value.Set(1) }) - t.Assert(err, nil) + t.AssertNil(err) callback2, err := gfsnotify.AddOnce("mywatch", path, func(event *gfsnotify.Event) { value.Set(2) }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(callback2, nil) err = gfile.PutContents(path, "1") - t.Assert(err, nil) + t.AssertNil(err) time.Sleep(100 * time.Millisecond) t.Assert(value, 1) err = gfsnotify.RemoveCallback(callback1.Id) - t.Assert(err, nil) + t.AssertNil(err) err = gfile.PutContents(path, "2") - t.Assert(err, nil) + t.AssertNil(err) time.Sleep(100 * time.Millisecond) t.Assert(value, 1) @@ -76,7 +76,7 @@ func TestWatcher_AddRemove(t *testing.T) { return } }) - t.Assert(err, nil) + t.AssertNil(err) t.AssertNE(callback, nil) gfile.PutContents(path1, "2") @@ -105,7 +105,7 @@ func TestWatcher_AddRemove(t *testing.T) { return } }) - t.Assert(err, nil) + t.AssertNil(err) t.AssertNE(callback, nil) gfile.PutContents(path1, "2") @@ -136,7 +136,7 @@ func TestWatcher_Callback1(t *testing.T) { return } }) - t.Assert(err, nil) + t.AssertNil(err) t.AssertNE(callback, nil) gfile.PutContents(path1, "2") diff --git a/os/glog/glog_z_unit_config_test.go b/os/glog/glog_z_unit_config_test.go index 6b33466d9..bb31284d8 100644 --- a/os/glog/glog_z_unit_config_test.go +++ b/os/glog/glog_z_unit_config_test.go @@ -24,7 +24,7 @@ func Test_SetConfigWithMap(t *testing.T) { "StStatus": 0, } err := l.SetConfigWithMap(m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(l.config.Path, m["path"]) t.Assert(l.config.Level, LEVEL_ALL) t.Assert(l.config.StdoutPrint, m["stdout"]) @@ -39,7 +39,7 @@ func Test_SetConfigWithMap_LevelStr(t *testing.T) { "level": "all", } err := l.SetConfigWithMap(m) - t.Assert(err, nil) + t.AssertNil(err) l.SetWriter(buffer) @@ -56,7 +56,7 @@ func Test_SetConfigWithMap_LevelStr(t *testing.T) { "level": "warn", } err := l.SetConfigWithMap(m) - t.Assert(err, nil) + t.AssertNil(err) l.SetWriter(buffer) l.Debug(ctx, "test") l.Warning(ctx, "test") diff --git a/os/glog/glog_z_unit_logger_chaining_test.go b/os/glog/glog_z_unit_logger_chaining_test.go index 1a0d958db..b794b8184 100644 --- a/os/glog/glog_z_unit_logger_chaining_test.go +++ b/os/glog/glog_z_unit_logger_chaining_test.go @@ -34,7 +34,7 @@ func Test_Path(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Stdout(false).Error(ctx, 1, 2, 3) @@ -52,7 +52,7 @@ func Test_Cat(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Cat(cat).Stdout(false).Error(ctx, 1, 2, 3) @@ -69,7 +69,7 @@ func Test_Level(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Level(LEVEL_PROD).Stdout(false).Debug(ctx, 1, 2, 3) @@ -86,7 +86,7 @@ func Test_Skip(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Skip(10).Stdout(false).Error(ctx, 1, 2, 3) @@ -105,7 +105,7 @@ func Test_Stack(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Stack(false).Stdout(false).Error(ctx, 1, 2, 3) @@ -124,7 +124,7 @@ func Test_StackWithFilter(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).StackWithFilter("none").Stdout(false).Error(ctx, 1, 2, 3) @@ -140,7 +140,7 @@ func Test_StackWithFilter(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).StackWithFilter("/gf/").Stdout(false).Error(ctx, 1, 2, 3) @@ -158,7 +158,7 @@ func Test_Header(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Header(true).Stdout(false).Error(ctx, 1, 2, 3) @@ -171,7 +171,7 @@ func Test_Header(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Header(false).Stdout(false).Error(ctx, 1, 2, 3) @@ -187,7 +187,7 @@ func Test_Line(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Line(true).Stdout(false).Debug(ctx, 1, 2, 3) @@ -203,7 +203,7 @@ func Test_Line(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Line(false).Stdout(false).Debug(ctx, 1, 2, 3) @@ -221,7 +221,7 @@ func Test_Async(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Async().Stdout(false).Debug(ctx, 1, 2, 3) @@ -239,7 +239,7 @@ func Test_Async(t *testing.T) { file := fmt.Sprintf(`%d.log`, gtime.TimestampNano()) err := gfile.Mkdir(path) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(path) Path(path).File(file).Async(false).Stdout(false).Debug(ctx, 1, 2, 3) diff --git a/os/glog/glog_z_unit_logger_rotate_test.go b/os/glog/glog_z_unit_logger_rotate_test.go index f17719054..e777746f9 100644 --- a/os/glog/glog_z_unit_logger_rotate_test.go +++ b/os/glog/glog_z_unit_logger_rotate_test.go @@ -38,7 +38,7 @@ func Test_Rotate_Size(t *testing.T) { "RotateBackupCompress": 9, "RotateCheckInterval": time.Second, // For unit testing only. }) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(p) s := "1234567890abcdefg" @@ -50,7 +50,7 @@ func Test_Rotate_Size(t *testing.T) { time.Sleep(time.Second * 3) files, err := gfile.ScanDirFile(p, "*.gz") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 2) content := gfile.GetContents(gfile.Join(p, "access.log")) @@ -58,7 +58,7 @@ func Test_Rotate_Size(t *testing.T) { time.Sleep(time.Second * 5) files, err = gfile.ScanDirFile(p, "*.gz") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 0) }) } @@ -77,7 +77,7 @@ func Test_Rotate_Expire(t *testing.T) { "RotateBackupCompress": 9, "RotateCheckInterval": time.Second, // For unit testing only. }) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(p) s := "1234567890abcdefg" @@ -86,7 +86,7 @@ func Test_Rotate_Expire(t *testing.T) { } files, err := gfile.ScanDirFile(p, "*.gz") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 0) t.Assert(gstr.Count(gfile.GetContents(gfile.Join(p, "access.log")), s), 10) @@ -94,14 +94,14 @@ func Test_Rotate_Expire(t *testing.T) { time.Sleep(time.Second * 3) files, err = gfile.ScanDirFile(p, "*.gz") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 1) t.Assert(gstr.Count(gfile.GetContents(gfile.Join(p, "access.log")), s), 0) time.Sleep(time.Second * 5) files, err = gfile.ScanDirFile(p, "*.gz") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(files), 0) }) } diff --git a/os/glog/glog_z_unit_test.go b/os/glog/glog_z_unit_test.go index f22677dbd..7f99cee0a 100644 --- a/os/glog/glog_z_unit_test.go +++ b/os/glog/glog_z_unit_test.go @@ -43,7 +43,7 @@ func Test_Ctx_Config(t *testing.T) { "CtxKeys": g.SliceStr{"Trace-Id", "Span-Id", "Test"}, } err := l.SetConfigWithMap(m) - t.Assert(err, nil) + t.AssertNil(err) ctx := context.WithValue(context.Background(), "Trace-Id", "1234567890") ctx = context.WithValue(ctx, "Span-Id", "abcdefg") diff --git a/os/gres/gres_z_unit_test.go b/os/gres/gres_z_unit_test.go index 1a1975410..2a5b424c7 100644 --- a/os/gres/gres_z_unit_test.go +++ b/os/gres/gres_z_unit_test.go @@ -28,7 +28,7 @@ func Test_PackToGoFile(t *testing.T) { pkgName = "testdata" err = gres.PackToGoFile(srcPath, goFilePath, pkgName) ) - t.Assert(err, nil) + t.AssertNil(err) _ = gfile.Remove(goFilePath) }) } @@ -39,11 +39,11 @@ func Test_Pack(t *testing.T) { srcPath = gdebug.TestDataPath("files") data, err = gres.Pack(srcPath) ) - t.Assert(err, nil) + t.AssertNil(err) r := gres.New() err = r.Add(string(data)) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Contains("files/"), true) }) } @@ -55,13 +55,13 @@ func Test_PackToFile(t *testing.T) { dstPath = gfile.Temp(gtime.TimestampNanoStr()) err = gres.PackToFile(srcPath, dstPath) ) - t.Assert(err, nil) + t.AssertNil(err) defer gfile.Remove(dstPath) r := gres.New() err = r.Load(dstPath) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r.Contains("files"), true) }) } @@ -74,9 +74,9 @@ func Test_PackMulti(t *testing.T) { pkgName = "data" array, err = gfile.ScanDir(srcPath, "*", false) ) - t.Assert(err, nil) + t.AssertNil(err) err = gres.PackToGoFile(strings.Join(array, ","), goFilePath, pkgName) - t.Assert(err, nil) + t.AssertNil(err) _ = gfile.Remove(goFilePath) }) } @@ -102,7 +102,7 @@ func Test_PackWithPrefix2(t *testing.T) { pkgName = "testdata" err = gres.PackToGoFile(srcPath, goFilePath, pkgName, "/var/www/gf-site/test") ) - t.Assert(err, nil) + t.AssertNil(err) _ = gfile.Remove(goFilePath) }) } @@ -127,13 +127,13 @@ func Test_Basic(t *testing.T) { t.Assert(info.Name(), "test1") rc, err := file.Open() - t.Assert(err, nil) + t.AssertNil(err) defer rc.Close() b := make([]byte, 5) n, err := rc.Read(b) t.Assert(n, 5) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(b), "test1") t.Assert(file.Content(), "test1 content") @@ -151,7 +151,7 @@ func Test_Basic(t *testing.T) { t.Assert(info.Name(), "dir2") rc, err := file.Open() - t.Assert(err, nil) + t.AssertNil(err) defer rc.Close() t.Assert(file.Content(), nil) diff --git a/os/gsession/gsession_z_unit_storage_redis_hashtable_test.go b/os/gsession/gsession_z_unit_storage_redis_hashtable_test.go index 22b5bdc44..c135d99a3 100644 --- a/os/gsession/gsession_z_unit_storage_redis_hashtable_test.go +++ b/os/gsession/gsession_z_unit_storage_redis_hashtable_test.go @@ -88,7 +88,7 @@ func Test_StorageRedisHashTablePrefix(t *testing.T) { Db: 0, }) gtest.C(t, func(t *gtest.T) { - t.Assert(err, nil) + t.AssertNil(err) }) prefix := "s_" diff --git a/os/gsession/gsession_z_unit_storage_redis_test.go b/os/gsession/gsession_z_unit_storage_redis_test.go index 13461c55f..dbb1e3d6a 100644 --- a/os/gsession/gsession_z_unit_storage_redis_test.go +++ b/os/gsession/gsession_z_unit_storage_redis_test.go @@ -22,7 +22,7 @@ func Test_StorageRedis(t *testing.T) { Address: "127.0.0.1:6379", Db: 0, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) storage := gsession.NewStorageRedis(redis) manager := gsession.New(time.Second, storage) @@ -86,7 +86,7 @@ func Test_StorageRedisPrefix(t *testing.T) { Address: "127.0.0.1:6379", Db: 0, }) - gtest.Assert(err, nil) + gtest.AssertNil(err) prefix := "s_" storage := gsession.NewStorageRedis(redis, prefix) diff --git a/os/gspath/gspath_z_unit_test.go b/os/gspath/gspath_z_unit_test.go index 907dff4b6..b269585a6 100644 --- a/os/gspath/gspath_z_unit_test.go +++ b/os/gspath/gspath_z_unit_test.go @@ -45,7 +45,7 @@ func TestSPath_Basic(t *testing.T) { defer gfile.Remove(gfile.Join(root, "gf_tmp")) gsp := gspath.New(root, false) realPath, err := gsp.Add(gfile.Join(root, "gf_tmp")) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(realPath, gfile.Join(root, "gf_tmp")) realPath, err = gsp.Add("gf_tmp1") t.Assert(err != nil, true) @@ -65,7 +65,7 @@ func TestSPath_Basic(t *testing.T) { t.Assert(realPath, "") realPath, err = gsp.Set(root) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(realPath, root) fp, isDir := gsp.Search("gf_tmp") @@ -80,7 +80,7 @@ func TestSPath_Basic(t *testing.T) { gsp = gspath.New(root, true) realPath, err = gsp.Add(gfile.Join(root, "gf_tmp")) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(realPath, gfile.Join(root, "gf_tmp")) gfile.Mkdir(gfile.Join(root, "gf_tmp1")) diff --git a/os/gtime/gtime_z_unit_feature_sql_test.go b/os/gtime/gtime_z_unit_feature_sql_test.go index b4133daad..015425bb0 100644 --- a/os/gtime/gtime_z_unit_feature_sql_test.go +++ b/os/gtime/gtime_z_unit_feature_sql_test.go @@ -30,12 +30,12 @@ func TestTime_Value(t1 *testing.T) { gtest.C(t1, func(t *gtest.T) { tt := gtime.Now() s, err := tt.Value() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(s, tt.Time) // test nil none := (*gtime.Time)(nil) s, err = none.Value() - t.Assert(err, nil) + t.AssertNil(err) t.Assert(s, nil) }) diff --git a/os/gtime/gtime_z_unit_test.go b/os/gtime/gtime_z_unit_test.go index a65635507..7d51f20ed 100644 --- a/os/gtime/gtime_z_unit_test.go +++ b/os/gtime/gtime_z_unit_test.go @@ -105,7 +105,7 @@ func Test_StrToTime(t *testing.T) { for _, item := range testDateTimes { timeTemp, err := gtime.StrToTime(item) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05") } @@ -118,7 +118,7 @@ func Test_StrToTime(t *testing.T) { for _, item := range testDates { timeTemp, err := gtime.StrToTime(item) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 00:00:00") } @@ -130,9 +130,9 @@ func Test_StrToTime(t *testing.T) { for k, v := range testTimes { time1, err := gtime.StrToTime(k) - t.Assert(err, nil) + t.AssertNil(err) time2, err := time.ParseInLocation(v, k, time.Local) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(time1.Time, time2) } @@ -232,22 +232,22 @@ func Test_ConvertZone(t *testing.T) { func Test_ParseDuration(t *testing.T) { gtest.C(t, func(t *gtest.T) { d, err := gtime.ParseDuration("1d") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(d.String(), "24h0m0s") }) gtest.C(t, func(t *gtest.T) { d, err := gtime.ParseDuration("1d2h3m") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(d.String(), "26h3m0s") }) gtest.C(t, func(t *gtest.T) { d, err := gtime.ParseDuration("-1d2h3m") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(d.String(), "-26h3m0s") }) gtest.C(t, func(t *gtest.T) { d, err := gtime.ParseDuration("3m") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(d.String(), "3m0s") }) // error diff --git a/os/gview/gview_z_unit_config_test.go b/os/gview/gview_z_unit_config_test.go index ea70d0a08..f8c125b5e 100644 --- a/os/gview/gview_z_unit_config_test.go +++ b/os/gview/gview_z_unit_config_test.go @@ -28,16 +28,16 @@ func Test_Config(t *testing.T) { } view := gview.New() err := view.SetConfig(config) - t.Assert(err, nil) + t.AssertNil(err) str := `hello ${.name},version:${.version}` view.Assigns(g.Map{"version": "1.7.0"}) result, err := view.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "hello gf,version:1.7.0") result, err = view.ParseDefault(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "name:gf") }) } @@ -53,16 +53,16 @@ func Test_ConfigWithMap(t *testing.T) { "name": "gf", }, }) - t.Assert(err, nil) + t.AssertNil(err) str := `hello ${.name},version:${.version}` view.Assigns(g.Map{"version": "1.7.0"}) result, err := view.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "hello gf,version:1.7.0") result, err = view.ParseDefault(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "name:gf") }) } diff --git a/os/gview/gview_z_unit_feature_encode_test.go b/os/gview/gview_z_unit_feature_encode_test.go index dc7913de5..55a3665ba 100644 --- a/os/gview/gview_z_unit_feature_encode_test.go +++ b/os/gview/gview_z_unit_feature_encode_test.go @@ -25,7 +25,7 @@ func Test_Encode_Parse(t *testing.T) { result, err := v.Parse(context.TODO(), "encode.tpl", g.Map{ "title": "my title", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "
<b>my title</b>
") }) } @@ -38,7 +38,7 @@ func Test_Encode_ParseContent(t *testing.T) { result, err := v.ParseContent(context.TODO(), tplContent, g.Map{ "title": "my title", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, "
<b>my title</b>
") }) } diff --git a/os/gview/gview_z_unit_i18n_test.go b/os/gview/gview_z_unit_i18n_test.go index 58c1c27d5..5b22b8250 100644 --- a/os/gview/gview_z_unit_i18n_test.go +++ b/os/gview/gview_z_unit_i18n_test.go @@ -29,21 +29,21 @@ func Test_I18n(t *testing.T) { result1, err := g.View().ParseContent(context.TODO(), content, g.Map{ "name": "john", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result1, expect1) g.I18n().SetLanguage("ja") result2, err := g.View().ParseContent(context.TODO(), content, g.Map{ "name": "john", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result2, expect2) g.I18n().SetLanguage("none") result3, err := g.View().ParseContent(context.TODO(), content, g.Map{ "name": "john", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result3, expect3) }) gtest.C(t, func(t *gtest.T) { @@ -58,21 +58,21 @@ func Test_I18n(t *testing.T) { "name": "john", "I18nLanguage": "zh-CN", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result1, expect1) result2, err := g.View().ParseContent(context.TODO(), content, g.Map{ "name": "john", "I18nLanguage": "ja", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result2, expect2) result3, err := g.View().ParseContent(context.TODO(), content, g.Map{ "name": "john", "I18nLanguage": "none", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result3, expect3) }) } diff --git a/os/gview/gview_z_unit_test.go b/os/gview/gview_z_unit_test.go index 8a298ea96..10468557d 100644 --- a/os/gview/gview_z_unit_test.go +++ b/os/gview/gview_z_unit_test.go @@ -176,7 +176,7 @@ func Test_Func(t *testing.T) { str = `{{concat "I" "Love" "GoFrame"}}` result, err = gview.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, `ILoveGoFrame`) }) // eq: multiple values. @@ -198,7 +198,7 @@ func Test_FuncNl2Br(t *testing.T) { gtest.C(t, func(t *gtest.T) { str := `{{"Go\nFrame" | nl2br}}` result, err := gview.ParseContent(context.TODO(), str, nil) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, `Go
Frame`) }) gtest.C(t, func(t *gtest.T) { @@ -210,7 +210,7 @@ func Test_FuncNl2Br(t *testing.T) { result, err := gview.ParseContent(context.TODO(), str, g.Map{ "content": s, }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, strings.Replace(s, "\n", "
", -1)) }) } @@ -305,7 +305,7 @@ func Test_HotReload(t *testing.T) { // Initialize data. err := gfile.PutContents(filePath, "test:{{.var}}") - t.Assert(err, nil) + t.AssertNil(err) view := gview.New(dirPath) @@ -313,18 +313,18 @@ func Test_HotReload(t *testing.T) { result, err := view.Parse(context.TODO(), "test.html", g.Map{ "var": "1", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, `test:1`) // Update data. err = gfile.PutContents(filePath, "test2:{{.var}}") - t.Assert(err, nil) + t.AssertNil(err) time.Sleep(100 * time.Millisecond) result, err = view.Parse(context.TODO(), "test.html", g.Map{ "var": "2", }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(result, `test2:2`) }) } @@ -336,7 +336,7 @@ func Test_XSS(t *testing.T) { r, err := v.ParseContent(context.TODO(), "{{.v}}", g.Map{ "v": s, }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, s) }) gtest.C(t, func(t *gtest.T) { @@ -346,7 +346,7 @@ func Test_XSS(t *testing.T) { r, err := v.ParseContent(context.TODO(), "{{.v}}", g.Map{ "v": s, }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, ghtml.Entities(s)) }) // Tag "if". @@ -357,7 +357,7 @@ func Test_XSS(t *testing.T) { r, err := v.ParseContent(context.TODO(), "{{if eq 1 1}}{{.v}}{{end}}", g.Map{ "v": s, }) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, ghtml.Entities(s)) }) } @@ -376,7 +376,7 @@ func Test_BuildInFuncMap(t *testing.T) { v := gview.New() v.Assign("v", new(TypeForBuildInFuncMap)) r, err := v.ParseContent(context.TODO(), "{{range $k, $v := map .v.Test}} {{$k}}:{{$v}} {{end}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(gstr.Contains(r, "Name:john"), true) t.Assert(gstr.Contains(r, "Score:99.9"), true) }) @@ -399,7 +399,7 @@ func Test_BuildInFuncMaps(t *testing.T) { v := gview.New() v.Assign("v", new(TypeForBuildInFuncMaps)) r, err := v.ParseContent(context.TODO(), "{{range $k, $v := maps .v.Test}} {{$k}}:{{$v.Name}} {{$v.Score}} {{end}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, ` 0:john 99.9 1:smith 100 `) }) } @@ -412,7 +412,7 @@ func Test_BuildInFuncDump(t *testing.T) { "score": 100, }) r, err := v.ParseContent(context.TODO(), "{{dump .}}") - t.Assert(err, nil) + t.AssertNil(err) fmt.Println(r) t.Assert(gstr.Contains(r, `"name": "john"`), true) t.Assert(gstr.Contains(r, `"score": 100`), true) @@ -426,7 +426,7 @@ func Test_BuildInFuncJson(t *testing.T) { "name": "john", }) r, err := v.ParseContent(context.TODO(), "{{json .v}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, `{"name":"john"}`) }) } @@ -438,7 +438,7 @@ func Test_BuildInFuncXml(t *testing.T) { "name": "john", }) r, err := v.ParseContent(context.TODO(), "{{xml .v}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, `john`) }) } @@ -499,7 +499,7 @@ func Test_BuildInFuncPlus(t *testing.T) { gtest.C(t, func(t *gtest.T) { v := gview.New() r, err := v.ParseContent(gctx.New(), "{{plus 1 2 3}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, `6`) }) } @@ -508,7 +508,7 @@ func Test_BuildInFuncMinus(t *testing.T) { gtest.C(t, func(t *gtest.T) { v := gview.New() r, err := v.ParseContent(gctx.New(), "{{minus 1 2 3}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, `-4`) }) } @@ -517,7 +517,7 @@ func Test_BuildInFuncTimes(t *testing.T) { gtest.C(t, func(t *gtest.T) { v := gview.New() r, err := v.ParseContent(gctx.New(), "{{times 1 2 3 4}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, `24`) }) } @@ -526,7 +526,7 @@ func Test_BuildInFuncDivide(t *testing.T) { gtest.C(t, func(t *gtest.T) { v := gview.New() r, err := v.ParseContent(gctx.New(), "{{divide 8 2 2}}") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(r, `2`) }) } diff --git a/text/gregex/gregex_z_unit_test.go b/text/gregex/gregex_z_unit_test.go index bf9aae5ab..ca07f8407 100644 --- a/text/gregex/gregex_z_unit_test.go +++ b/text/gregex/gregex_z_unit_test.go @@ -70,7 +70,7 @@ func Test_Match(t *testing.T) { wantSubs := "aaabb" s := "acbb" + wantSubs + "dd" subs, err := gregex.Match(re, []byte(s)) - t.Assert(err, nil) + t.AssertNil(err) if string(subs[0]) != wantSubs { t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0], wantSubs) } @@ -89,7 +89,7 @@ func Test_MatchString(t *testing.T) { wantSubs := "aaabb" s := "acbb" + wantSubs + "dd" subs, err := gregex.MatchString(re, s) - t.Assert(err, nil) + t.AssertNil(err) if string(subs[0]) != wantSubs { t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0], wantSubs) } @@ -109,7 +109,7 @@ func Test_MatchAll(t *testing.T) { s := "acbb" + wantSubs + "dd" s = s + `其他的` + s subs, err := gregex.MatchAll(re, []byte(s)) - t.Assert(err, nil) + t.AssertNil(err) if string(subs[0][0]) != wantSubs { t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0][0], wantSubs) } @@ -135,7 +135,7 @@ func Test_MatchAllString(t *testing.T) { wantSubs := "aaabb" s := "acbb" + wantSubs + "dd" subs, err := gregex.MatchAllString(re, s+`其他的`+s) - t.Assert(err, nil) + t.AssertNil(err) if string(subs[0][0]) != wantSubs { t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0][0], wantSubs) } @@ -163,7 +163,7 @@ func Test_Replace(t *testing.T) { s := "acbb" + wantSubs + "dd" wanted := "acbb" + replace + "dd" replacedStr, err := gregex.Replace(re, []byte(replace), []byte(s)) - t.Assert(err, nil) + t.AssertNil(err) if string(replacedStr) != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } @@ -181,7 +181,7 @@ func Test_ReplaceString(t *testing.T) { s := "acbb" + wantSubs + "dd" wanted := "acbb" + replace + "dd" replacedStr, err := gregex.ReplaceString(re, replace, s) - t.Assert(err, nil) + t.AssertNil(err) if replacedStr != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } @@ -205,7 +205,7 @@ func Test_ReplaceFun(t *testing.T) { } return []byte("[x" + string(s) + "y]") }) - t.Assert(err, nil) + t.AssertNil(err) if string(replacedStr) != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } @@ -263,7 +263,7 @@ func Test_ReplaceStringFunc(t *testing.T) { } return "[x" + s + "y]" }) - t.Assert(err, nil) + t.AssertNil(err) if replacedStr != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } diff --git a/text/gstr/gstr_z_unit_parse_test.go b/text/gstr/gstr_z_unit_parse_test.go index 1dbed1ac5..9d4bd90cd 100644 --- a/text/gstr/gstr_z_unit_parse_test.go +++ b/text/gstr/gstr_z_unit_parse_test.go @@ -22,41 +22,41 @@ func Test_Parse(t *testing.T) { gtest.C(t, func(t *gtest.T) { s := "goframe.org/index?name=john&score=100" u, err := url.Parse(s) - t.Assert(err, nil) + t.AssertNil(err) m, err := gstr.Parse(u.RawQuery) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m["name"], "john") t.Assert(m["score"], "100") // name overwrite m, err = gstr.Parse("a=1&a=2") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "a": 2, }) // slice m, err = gstr.Parse("a[]=1&a[]=2") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "a": g.Slice{"1", "2"}, }) // map m, err = gstr.Parse("a=1&b=2&c=3") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "a": "1", "b": "2", "c": "3", }) m, err = gstr.Parse("a=1&a=2&c=3") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "a": "2", "c": "3", }) // map m, err = gstr.Parse("m[a]=1&m[b]=2&m[c]=3") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "m": g.Map{ "a": "1", @@ -65,7 +65,7 @@ func Test_Parse(t *testing.T) { }, }) m, err = gstr.Parse("m[a]=1&m[a]=2&m[b]=3") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "m": g.Map{ "a": "2", @@ -74,14 +74,14 @@ func Test_Parse(t *testing.T) { }) // map - slice m, err = gstr.Parse("m[a][]=1&m[a][]=2") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "m": g.Map{ "a": g.Slice{"1", "2"}, }, }) m, err = gstr.Parse("m[a][b][]=1&m[a][b][]=2") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "m": g.Map{ "a": g.Map{ @@ -91,7 +91,7 @@ func Test_Parse(t *testing.T) { }) // map - complicated m, err = gstr.Parse("m[a1][b1][c1][d1]=1&m[a2][b2]=2&m[a3][b3][c3]=3") - t.Assert(err, nil) + t.AssertNil(err) t.Assert(m, g.Map{ "m": g.Map{ "a1": g.Map{ diff --git a/util/gconv/gconv_z_unit_all_test.go b/util/gconv/gconv_z_unit_all_test.go index 6868e5d95..ab04223cc 100644 --- a/util/gconv/gconv_z_unit_all_test.go +++ b/util/gconv/gconv_z_unit_all_test.go @@ -1366,7 +1366,7 @@ func Test_Struct_PrivateAttribute_All(t *testing.T) { gtest.C(t, func(t *gtest.T) { user := new(User) err := gconv.Struct(g.Map{"id": 1, "name": "john"}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Id, 1) t.Assert(user.name, "") }) diff --git a/util/gconv/gconv_z_unit_custom_type_test.go b/util/gconv/gconv_z_unit_custom_type_test.go index 1bf79cd87..d6b168b63 100644 --- a/util/gconv/gconv_z_unit_custom_type_test.go +++ b/util/gconv/gconv_z_unit_custom_type_test.go @@ -36,6 +36,6 @@ func Test_Struct_CustomTimeDuration_Attribute(t *testing.T) { "name": "john", "timeout": "1s", }, &a) - t.Assert(err, nil) + t.AssertNil(err) }) } diff --git a/util/gconv/gconv_z_unit_map_test.go b/util/gconv/gconv_z_unit_map_test.go index c34897909..634d0ebd1 100644 --- a/util/gconv/gconv_z_unit_map_test.go +++ b/util/gconv/gconv_z_unit_map_test.go @@ -464,14 +464,14 @@ field3: parsed := &Outer{} err := yaml.Unmarshal(problemYaml, parsed) - t.Assert(err, nil) + t.AssertNil(err) _, err = json.Marshal(parsed) t.Assert(err.Error(), "json: unsupported type: map[interface {}]interface {}") converted := gconv.MapDeep(parsed) jsonData, err := json.Marshal(converted) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(string(jsonData), `{"field3":{"123":"integer_key"},"outer_struct":{"field1":{"inner1":123,"inner2":345},"field2":{"inner1":123,"inner2":345,"inner3":456,"inner4":789}}}`) }) diff --git a/util/gconv/gconv_z_unit_maptomap_test.go b/util/gconv/gconv_z_unit_maptomap_test.go index ea0aa9db2..78500ec99 100644 --- a/util/gconv/gconv_z_unit_maptomap_test.go +++ b/util/gconv/gconv_z_unit_maptomap_test.go @@ -91,7 +91,7 @@ func Test_MapToMap2(t *testing.T) { gtest.C(t, func(t *gtest.T) { m := (map[string]User)(nil) err := gconv.MapToMap(params, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(m), 1) t.Assert(m["key"].Id, 1) t.Assert(m["key"].Name, "john") @@ -99,7 +99,7 @@ func Test_MapToMap2(t *testing.T) { gtest.C(t, func(t *gtest.T) { m := make(map[string]*User) err := gconv.MapToMap(params, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(m), 1) t.Assert(m["key"].Id, 1) t.Assert(m["key"].Name, "john") @@ -107,7 +107,7 @@ func Test_MapToMap2(t *testing.T) { gtest.C(t, func(t *gtest.T) { m := (map[string]*User)(nil) err := gconv.MapToMap(params, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(m), 1) t.Assert(m["key"].Id, 1) t.Assert(m["key"].Name, "john") @@ -136,7 +136,7 @@ func Test_MapToMapDeep(t *testing.T) { gtest.C(t, func(t *gtest.T) { m := (map[string]*User)(nil) err := gconv.MapToMap(params, &m) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(m), 1) t.Assert(m["key"].Id, 1) t.Assert(m["key"].Name, "john") diff --git a/util/gconv/gconv_z_unit_scan_test.go b/util/gconv/gconv_z_unit_scan_test.go index 12d488d90..f94bf3e1a 100644 --- a/util/gconv/gconv_z_unit_scan_test.go +++ b/util/gconv/gconv_z_unit_scan_test.go @@ -35,7 +35,7 @@ func Test_Scan_StructStructs(t *testing.T) { } ) err := gconv.Scan(params, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user, &User{ Uid: 1, Name: "john", @@ -93,7 +93,7 @@ func Test_Scan_StructStr(t *testing.T) { params = `{"uid":1,"name":"john", "pass1":"123","pass2":"456"}` ) err := gconv.Scan(params, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user, &User{ Uid: 1, Name: "john", @@ -110,7 +110,7 @@ func Test_Scan_StructStr(t *testing.T) { ]` ) err := gconv.Scan(params, &users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(users, g.Slice{ &User{ Uid: 1, diff --git a/util/gconv/gconv_z_unit_slice_test.go b/util/gconv/gconv_z_unit_slice_test.go index 750711daa..019bf4aec 100644 --- a/util/gconv/gconv_z_unit_slice_test.go +++ b/util/gconv/gconv_z_unit_slice_test.go @@ -163,7 +163,7 @@ func Test_Slice_Structs(t *testing.T) { {"id": 2, "name": "smith", "age": 20}, } err := gconv.Structs(params, &users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(users), 2) t.Assert(users[0].Id, params[0]["id"]) t.Assert(users[0].Name, params[0]["name"]) diff --git a/util/gconv/gconv_z_unit_struct_marshal_unmarshal_test.go b/util/gconv/gconv_z_unit_struct_marshal_unmarshal_test.go index c6381923b..b200e732b 100644 --- a/util/gconv/gconv_z_unit_struct_marshal_unmarshal_test.go +++ b/util/gconv/gconv_z_unit_struct_marshal_unmarshal_test.go @@ -40,7 +40,7 @@ func Test_Struct_UnmarshalValue1(t *testing.T) { gtest.C(t, func(t *gtest.T) { st := &MyTimeSt{} err := gconv.Struct(g.Map{"ServiceDate": "2020-10-10 12:00:01"}, st) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(st.ServiceDate.Time.Format("2006-01-02 15:04:05"), "2020-10-10 12:00:01") }) gtest.C(t, func(t *gtest.T) { @@ -103,7 +103,7 @@ func Test_Struct_UnmarshalValue2(t *testing.T) { var p1, p2 *Pkg p1 = NewPkg([]byte("123")) err := gconv.Struct(p1.Marshal(), &p2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(p1, p2) }) } diff --git a/util/gconv/gconv_z_unit_struct_test.go b/util/gconv/gconv_z_unit_struct_test.go index a224b746a..d48050313 100644 --- a/util/gconv/gconv_z_unit_struct_test.go +++ b/util/gconv/gconv_z_unit_struct_test.go @@ -341,7 +341,7 @@ func Test_Struct_Attr_CustomType1(t *testing.T) { gtest.C(t, func(t *gtest.T) { user := new(User) err := gconv.Struct(g.Map{"id": 1, "name": "john"}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Id, 1) t.Assert(user.Name, "john") }) @@ -409,7 +409,7 @@ func Test_Struct_PrivateAttribute(t *testing.T) { gtest.C(t, func(t *gtest.T) { user := new(User) err := gconv.Struct(g.Map{"id": 1, "name": "john"}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Id, 1) t.Assert(user.name, "") }) @@ -432,7 +432,7 @@ func Test_StructEmbedded1(t *testing.T) { "age": 18, } err := gconv.Struct(params, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Id, params["id"]) t.Assert(user.Name, params["name"]) t.Assert(user.Age, 18) @@ -460,7 +460,7 @@ func Test_StructEmbedded2(t *testing.T) { gtest.C(t, func(t *gtest.T) { user := new(User) err := gconv.Struct(params, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Id, 1) t.Assert(user.Uid, 10) t.Assert(user.Name, "john") @@ -493,7 +493,7 @@ func Test_StructEmbedded3(t *testing.T) { } user := new(User) err := gconv.Struct(data, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Id, 100) t.Assert(user.Uid, 101) t.Assert(user.Nickname, "T1") @@ -565,16 +565,16 @@ func Test_StructEmbedded5(t *testing.T) { user1 := new(UserWithBase1) user2 := new(UserWithBase2) err = gconv.Struct(data, user1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user1, &UserWithBase1{1, "john", Base{"123", "456"}}) err = gconv.Struct(data, user2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user2, &UserWithBase2{1, "john", Base{"", ""}}) var user3 *UserWithBase1 err = gconv.Struct(user1, &user3) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user3, user1) }) } @@ -670,7 +670,7 @@ func Test_Struct_Create(t *testing.T) { "Name": "john", } err := gconv.Struct(params, &user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Uid, 1) t.Assert(user.Name, "john") }) @@ -703,7 +703,7 @@ func Test_Struct_Interface(t *testing.T) { "Name": nil, } err := gconv.Struct(params, &user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Uid, 1) t.Assert(user.Name, nil) }) @@ -732,7 +732,7 @@ func Test_Struct_NilAttribute(t *testing.T) { "txt": "hello", "items": nil, }, m) - t.Assert(err, nil) + t.AssertNil(err) t.AssertNE(m.Me, nil) t.Assert(m.Me["day"], "20009") t.Assert(m.Items, nil) @@ -875,11 +875,11 @@ func Test_Struct_Complex(t *testing.T) { }` m := make(g.Map) err := json.UnmarshalUseNumber([]byte(data), &m) - t.Assert(err, nil) + t.AssertNil(err) model := new(XinYanModel) err = gconv.Struct(m, model) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(model.ErrorCode, nil) t.Assert(model.ErrorMsg, nil) t.Assert(model.Success, true) @@ -934,7 +934,7 @@ func Test_Struct_Embedded(t *testing.T) { } v2 := g.Map{} err := gconv.Struct(v2, &v1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v1.Test(), "john") }) // Implemented interface attribute. @@ -946,7 +946,7 @@ func Test_Struct_Embedded(t *testing.T) { "name": "test", } err := gconv.Struct(v2, &v1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v1.Test(), "test") }) // No implemented interface attribute. @@ -956,7 +956,7 @@ func Test_Struct_Embedded(t *testing.T) { "name": "test", } err := gconv.Struct(v2, &v1) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(v1.TestInterface, nil) }) } @@ -969,7 +969,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) gtest.C(t, func(t *gtest.T) { @@ -979,7 +979,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) gtest.C(t, func(t *gtest.T) { @@ -989,7 +989,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) gtest.C(t, func(t *gtest.T) { @@ -999,7 +999,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) gtest.C(t, func(t *gtest.T) { @@ -1009,7 +1009,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) gtest.C(t, func(t *gtest.T) { @@ -1019,7 +1019,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) gtest.C(t, func(t *gtest.T) { @@ -1029,7 +1029,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) gtest.C(t, func(t *gtest.T) { @@ -1039,7 +1039,7 @@ func Test_Struct_Slice(t *testing.T) { user := new(User) array := g.Slice{1, 2, 3} err := gconv.Struct(g.Map{"scores": array}, user) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(user.Scores, array) }) } @@ -1079,7 +1079,7 @@ func Test_Struct_WithJson(t *testing.T) { b, _ := json.Marshal(b1) b2 := &B{} err := gconv.Struct(b, b2) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(b2, b1) }) } @@ -1103,7 +1103,7 @@ func Test_Struct_AttrStructHasTheSameTag(t *testing.T) { } order := new(Order) err := gconv.Struct(data, order) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(order.Id, data["id"]) t.Assert(order.UpdatedAt, data["updated_at"]) t.Assert(order.Product.Id, 0) @@ -1127,7 +1127,7 @@ func Test_Struct_DirectReflectSet(t *testing.T) { b *A ) err := gconv.Struct(a, &b) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(a, b) }) gtest.C(t, func(t *gtest.T) { @@ -1139,7 +1139,7 @@ func Test_Struct_DirectReflectSet(t *testing.T) { b A ) err := gconv.Struct(a, &b) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(a, b) }) } @@ -1161,7 +1161,7 @@ func Test_Struct_NilEmbeddedStructAttribute(t *testing.T) { "id": 1, "name": nil, }, &b) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(b.Id, 1) t.Assert(b.Name, "") }) @@ -1176,7 +1176,7 @@ func Test_Struct_JsonParam(t *testing.T) { gtest.C(t, func(t *gtest.T) { var a = A{} err := gconv.Struct([]byte(`{"id":1,"name":"john"}`), &a) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a.Id, 1) t.Assert(a.Name, "john") }) @@ -1184,7 +1184,7 @@ func Test_Struct_JsonParam(t *testing.T) { gtest.C(t, func(t *gtest.T) { var a = &A{} err := gconv.Struct([]byte(`{"id":1,"name":"john"}`), a) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a.Id, 1) t.Assert(a.Name, "john") }) @@ -1192,7 +1192,7 @@ func Test_Struct_JsonParam(t *testing.T) { gtest.C(t, func(t *gtest.T) { var a *A err := gconv.Struct([]byte(`{"id":1,"name":"john"}`), &a) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a.Id, 1) t.Assert(a.Name, "john") }) @@ -1214,7 +1214,7 @@ func Test_Struct_GVarAttribute(t *testing.T) { } ) err := gconv.Struct(data, &a) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(a.Id, data["id"]) t.Assert(a.Name, data["name"]) t.Assert(a.Status, data["status"]) diff --git a/util/gconv/gconv_z_unit_structs_test.go b/util/gconv/gconv_z_unit_structs_test.go index f834fbb6b..673379b07 100644 --- a/util/gconv/gconv_z_unit_structs_test.go +++ b/util/gconv/gconv_z_unit_structs_test.go @@ -32,7 +32,7 @@ func Test_Structs_WithTag(t *testing.T) { }, } err := gconv.Structs(params, &users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(users), 2) t.Assert(users[0].Uid, 1) t.Assert(users[0].NickName, "name1") @@ -52,7 +52,7 @@ func Test_Structs_WithTag(t *testing.T) { }, } err := gconv.Structs(params, &users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(users), 2) t.Assert(users[0].Uid, 1) t.Assert(users[0].NickName, "name1") @@ -79,7 +79,7 @@ func Test_Structs_WithoutTag(t *testing.T) { }, } err := gconv.Structs(params, &users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(users), 2) t.Assert(users[0].Uid, 1) t.Assert(users[0].NickName, "name1") @@ -99,7 +99,7 @@ func Test_Structs_WithoutTag(t *testing.T) { }, } err := gconv.Structs(params, &users) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(users), 2) t.Assert(users[0].Uid, 1) t.Assert(users[0].NickName, "name1") @@ -166,7 +166,7 @@ func Test_Structs_DirectReflectSet(t *testing.T) { b []*A ) err := gconv.Structs(a, &b) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(a, b) }) gtest.C(t, func(t *gtest.T) { @@ -178,7 +178,7 @@ func Test_Structs_DirectReflectSet(t *testing.T) { b []A ) err := gconv.Structs(a, &b) - t.Assert(err, nil) + t.AssertNil(err) t.AssertEQ(a, b) }) } @@ -199,7 +199,7 @@ func Test_Structs_IntSliceAttribute(t *testing.T) { g.Map{"id": nil, "name": "john"}, g.Map{"id": nil, "name": "smith"}, }, &array) - t.Assert(err, nil) + t.AssertNil(err) t.Assert(len(array), 2) t.Assert(array[0].Name, "john") t.Assert(array[1].Name, "smith") diff --git a/util/gvalid/gvalid_z_unit_feature_checkmap_test.go b/util/gvalid/gvalid_z_unit_feature_checkmap_test.go index 9cdb0d4ba..f3fba9a7b 100755 --- a/util/gvalid/gvalid_z_unit_feature_checkmap_test.go +++ b/util/gvalid/gvalid_z_unit_feature_checkmap_test.go @@ -40,7 +40,7 @@ func Test_CheckMap2(t *testing.T) { var params interface{} gtest.C(t, func(t *gtest.T) { if err := g.Validator().Data(params).Run(context.TODO()); err == nil { - t.Assert(err, nil) + t.AssertNil(err) } }) diff --git a/util/gvalid/gvalid_z_unit_feature_checkstruct_test.go b/util/gvalid/gvalid_z_unit_feature_checkstruct_test.go index 237938d99..7e182d84c 100755 --- a/util/gvalid/gvalid_z_unit_feature_checkstruct_test.go +++ b/util/gvalid/gvalid_z_unit_feature_checkstruct_test.go @@ -35,7 +35,7 @@ func Test_CheckStruct(t *testing.T) { } obj := &Object{"john", 16} err := g.Validator().Data(obj).Rules(rules).Messages(msgs).Run(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) }) gtest.C(t, func(t *gtest.T) { @@ -133,7 +133,7 @@ func Test_CheckStruct(t *testing.T) { } var login LoginRequest err := g.Validator().Data(login).Run(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) }) gtest.C(t, func(t *gtest.T) { @@ -249,7 +249,7 @@ func Test_CheckStruct_EmbeddedObject_Attribute(t *testing.T) { obj.Name = "john" obj.Time = gtime.Now() err := g.Validator().Data(obj).Rules(rules).Messages(ruleMsg).Run(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) }) gtest.C(t, func(t *gtest.T) { type Base struct { @@ -273,7 +273,7 @@ func Test_CheckStruct_EmbeddedObject_Attribute(t *testing.T) { obj.Type = 1 obj.Name = "john" err := g.Validator().Data(obj).Rules(rules).Messages(ruleMsg).Run(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -341,7 +341,7 @@ func Test_CheckStruct_Optional(t *testing.T) { Size: 10, } err := g.Validator().Data(obj).Run(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) }) gtest.C(t, func(t *gtest.T) { type Params struct { @@ -354,7 +354,7 @@ func Test_CheckStruct_Optional(t *testing.T) { Size: 10, } err := g.Validator().Data(obj).Run(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) }) gtest.C(t, func(t *gtest.T) { type Params struct { @@ -383,7 +383,7 @@ func Test_CheckStruct_NoTag(t *testing.T) { Size: 10, } err := g.Validator().Data(obj).Run(context.TODO()) - t.Assert(err, nil) + t.AssertNil(err) }) } diff --git a/util/gvalid/gvalid_z_unit_feature_custom_rule_test.go b/util/gvalid/gvalid_z_unit_feature_custom_rule_test.go index 8aaf05eee..82cf83125 100644 --- a/util/gvalid/gvalid_z_unit_feature_custom_rule_test.go +++ b/util/gvalid/gvalid_z_unit_feature_custom_rule_test.go @@ -39,7 +39,7 @@ func Test_CustomRule1(t *testing.T) { err := g.Validator().Data("123456").Rules(rule).Messages("custom message").Run(ctx) t.Assert(err.String(), "custom message") err = g.Validator().Data("123456").Assoc(g.Map{"data": "123456"}).Rules(rule).Messages("custom message").Run(ctx) - t.Assert(err, nil) + t.AssertNil(err) }) // Error with struct validation. gtest.C(t, func(t *gtest.T) { @@ -65,7 +65,7 @@ func Test_CustomRule1(t *testing.T) { Data: "123456", } err := g.Validator().Data(st).Run(ctx) - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -108,7 +108,7 @@ func Test_CustomRule2(t *testing.T) { Data: "123456", } err := g.Validator().Data(st).Run(ctx) - t.Assert(err, nil) + t.AssertNil(err) }) } @@ -139,7 +139,7 @@ func Test_CustomRule_AllowEmpty(t *testing.T) { Data: "123456", } err := g.Validator().Data(st).Run(ctx) - t.Assert(err, nil) + t.AssertNil(err) }) // No error with struct validation. gtest.C(t, func(t *gtest.T) { diff --git a/util/gvalid/gvalid_z_unit_feature_rule_test.go b/util/gvalid/gvalid_z_unit_feature_rule_test.go index f249ed73b..5229ef9b4 100755 --- a/util/gvalid/gvalid_z_unit_feature_rule_test.go +++ b/util/gvalid/gvalid_z_unit_feature_rule_test.go @@ -670,7 +670,7 @@ func Test_Domain(t *testing.T) { err = g.Validator().Data(k).Rules("domain").Run(ctx) if v { // fmt.Println(k) - t.Assert(err, nil) + t.AssertNil(err) } else { // fmt.Println(k) t.AssertNE(err, nil) From ba7cbfe3d97bd9236abfd0c4e48ea8755a8c55db Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 10 Mar 2022 14:29:49 +0800 Subject: [PATCH 079/136] error message update for database driver import --- database/gdb/gdb.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/database/gdb/gdb.go b/database/gdb/gdb.go index d054033f0..82594aa01 100644 --- a/database/gdb/gdb.go +++ b/database/gdb/gdb.go @@ -409,7 +409,8 @@ func doNewByNode(node ConfigNode, group string) (db DB, err error) { return c.db, nil } errorMsg := `cannot find database driver for specified database type "%s"` - errorMsg += `, did you misspell type name "%s" or forget importing the database driver?` + errorMsg += `, did you misspell type name "%s" or forget importing the database driver? ` + errorMsg += `possible reference: https://github.com/gogf/gf/tree/master/contrib/drivers` return nil, gerror.NewCodef(gcode.CodeInvalidConfiguration, errorMsg, node.Type, node.Type) } From 581397947994b6a63f60058aba8c7b5a166fe564 Mon Sep 17 00:00:00 2001 From: sunmoon <“i@liming.me”> Date: Thu, 10 Mar 2022 14:32:06 +0800 Subject: [PATCH 080/136] =?UTF-8?q?=E9=87=8D=E8=B7=91ci?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- net/ghttp/ghttp_request_param_request.go | 1 - 1 file changed, 1 deletion(-) diff --git a/net/ghttp/ghttp_request_param_request.go b/net/ghttp/ghttp_request_param_request.go index c08fa0a8b..8f5531676 100644 --- a/net/ghttp/ghttp_request_param_request.go +++ b/net/ghttp/ghttp_request_param_request.go @@ -22,7 +22,6 @@ import ( // // Note that if there are multiple parameters with the same name, the parameters are // retrieved and overwrote in order of priority: router < query < body < form < custom. - func (r *Request) GetRequest(key string, def ...interface{}) *gvar.Var { value := r.GetParam(key) if value.IsNil() { From 87b1433473efbce78ca411203f702e2e8b692da2 Mon Sep 17 00:00:00 2001 From: John Guo Date: Thu, 10 Mar 2022 19:30:03 +0800 Subject: [PATCH 081/136] issue template update --- .github/ISSUE_TEMPLATE.MD | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/.github/ISSUE_TEMPLATE.MD b/.github/ISSUE_TEMPLATE.MD index 364044d16..540e46b4b 100644 --- a/.github/ISSUE_TEMPLATE.MD +++ b/.github/ISSUE_TEMPLATE.MD @@ -1,12 +1,11 @@ - - - + + + ### 1. What version of `Go` and system type/arch are you using? - @@ -23,7 +21,6 @@ What expect to see is like: `go 1.12, linux/amd64` ### 4. What did you do? -