test utl

.gitignore

@@ -1,2 +1,3 @@
 .idea/
 *.log
+*.png

go.mod

@@ -24,9 +24,10 @@ require (
 	github.com/grpc-ecosystem/grpc-gateway v1.9.0 // indirect
 	github.com/jonboulle/clockwork v0.1.0 // indirect
 	github.com/modern-go/reflect2 v1.0.1 // indirect
-	github.com/mojocn/base64Captcha v1.3.1 // indirect
+	github.com/mojocn/base64Captcha v1.3.1
 	github.com/natefinch/lumberjack v2.0.0+incompatible
 	github.com/nats-io/nats-server/v2 v2.1.9 // indirect
+	github.com/nats-io/nats.go v1.10.0
 	github.com/onsi/ginkgo v1.14.2 // indirect
 	github.com/onsi/gomega v1.10.4 // indirect
 	github.com/prometheus/client_golang v0.9.3 // indirect

go.sum

@@ -146,7 +146,6 @@ github.com/natefinch/lumberjack v2.0.0+incompatible/go.mod h1:Wi9p2TTF5DG5oU+6Yf
 github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU=
 github.com/nats-io/jwt v1.1.0 h1:+vOlgtM0ZsF46GbmUoadq0/2rChNS45gtxHEa3H1gqM=
 github.com/nats-io/jwt v1.1.0/go.mod h1:n3cvmLfBfnpV4JJRN7lRYCyZnw48ksGsbThGXEk4w9M=
-github.com/nats-io/nats-server v1.4.1 h1:Ul1oSOGNV/L8kjr4v6l2f9Yet6WY+LevH1/7cRZ/qyA=
 github.com/nats-io/nats-server/v2 v2.1.9 h1:Sxr2zpaapgpBT9ElTxTVe62W+qjnhPcKY/8W5cnA/Qk=
 github.com/nats-io/nats-server/v2 v2.1.9/go.mod h1:9qVyoewoYXzG1ME9ox0HwkkzyYvnlBDugfR4Gg/8uHU=
 github.com/nats-io/nats.go v1.10.0 h1:L8qnKaofSfNFbXg0C5F71LdjPRnmQwSsA4ukmkt1TvY=

utl/catpcha_test.go

@@ -1,3 +1,25 @@
 package utl
 
+import (
+	"encoding/base64"
+	"io/ioutil"
+	"testing"
+)
 
+func TestCatpcha(t *testing.T) {
+	c := NewDigitCatpcha(6)
+	id, b64, err := c.Gen()
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := base64.StdEncoding.DecodeString(b64[22:])
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = ioutil.WriteFile("./a.png", data, 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	AssertFalse(c.Verify(id, "12345"), "should not equal", t)
+}

utl/common.go

@@ -6,10 +6,10 @@ import (
 )
 
 var (
-	ErrNotImplement = errors.New("not implemented yet")
+	ErrNotImplement       = errors.New("not implemented yet")
 	ErrInterfaceTransform = errors.New("interface transform failed")
-	ErrParameters = errors.New("invalid parameters")
-	ErrContainerEmpty = errors.New("target container is empty")
+	ErrParameters         = errors.New("invalid parameters")
+	ErrContainerEmpty     = errors.New("target container is empty")
 )
 
 func ErrForCode(code int) error {
@@ -24,4 +24,4 @@ func ErrPanic(err error) {
 
 func UnUsed(v ...interface{}) {
 
-}
+}

utl/smap.go

@@ -50,7 +50,7 @@ func (self *SMap) Insert(k, v interface{}) error {
 	self.Lock()
 	defer self.Unlock()
 
-	v, ok := self.m[k]
+	_, ok := self.m[k]
 	if ok {
 		return ErrKeyExists
 	}
@@ -64,7 +64,7 @@ func (self *SMap) Update(k, v interface{}) error {
 	self.Lock()
 	defer self.Unlock()
 
-	v, ok := self.m[k]
+	_, ok := self.m[k]
 	if !ok {
 		return ErrKeyNotExists
 	}

utl/smap_test.go

@@ -1 +1,39 @@
 package utl
+
+import (
+	"testing"
+)
+
+func TestSMap(t *testing.T) {
+	m := NewSMap()
+	AssertFalse(m.Exists(20), "smap should empty", t)
+
+	err := m.Insert("h", "good")
+	AssertNil(err, "h not exists in smap", t)
+
+	val, ok := m.Get("h")
+	AssertTrue(ok && val == "good", "h==good:"+val.(string), t)
+
+	err = m.Insert("h", "ggd")
+	AssertErr(err, "h exists", t)
+
+	m.Set("h", "hh")
+	_, ok = m.Get("dd")
+	AssertFalse(ok, "dd should not exists in smap", t)
+
+	val, ok = m.Get("h")
+	AssertTrue(ok, "h exists", t)
+	AssertTrue(val == "hh", "Set is force", t)
+
+	err = m.Update("t", "jj")
+	AssertErr(err, "t not exists", t)
+
+	err = m.Update("h", "jj")
+	AssertNil(err, "update h", t)
+
+	val, ok = m.Get("h")
+	AssertTrue(ok && val == "jj", "updated h:"+val.(string), t)
+
+	t.Log(m.Keys())
+	t.Log(m.Values())
+}

utl/smtp.go

@@ -5,18 +5,28 @@ import (
 )
 
 type Smtp struct {
-	Host string
-	Port int
-	Username, Password string
-	Alias string
+	host               string
+	port               int
+	username, password string
+	alias              string
+}
+
+func NewSmtp(host string, port int, username, password, alias string) *Smtp {
+	return &Smtp{
+		host:     host,
+		port:     port,
+		username: username,
+		password: password,
+		alias:    alias,
+	}
 }
 
 func (self *Smtp) Send(to []string, subject, body string) error {
-	m := gomail.NewMessage(/* gomail.SetEncoding(gomail.Base64) */)
-	m.SetHeader("From", m.FormatAddress(self.Username, self.Alias))
+	m := gomail.NewMessage( /* gomail.SetEncoding(gomail.Base64) */ )
+	m.SetHeader("From", m.FormatAddress(self.username, self.alias))
 	m.SetHeader("To", to...)
 	m.SetHeader("Subject", subject)
-	m.SetHeader("text/html", body)
+	m.SetBody("text/html", body)
 	//m.Attach("/tmp/foo.txt",
 	//	gomail.Rename("foo.txt"),
 	//	gomail.SetHeader(map[string][]string{
@@ -25,6 +35,6 @@ func (self *Smtp) Send(to []string, subject, body string) error {
 	//		},
 	//	}),
 	//)
-	d := gomail.NewDialer(self.Host, self.Port, self.Username, self.Password)
+	d := gomail.NewDialer(self.host, self.port, self.username, self.password)
 	return d.DialAndSend(m)
 }

utl/smtp_test.go

@@ -1 +1,16 @@
 package utl
+
+import "testing"
+
+func TestSmtp_Send(t *testing.T) {
+	smtp := NewSmtp("smtp.163.com", 465, "yyk882002@163.com", "3#initialize", "wen.studio")
+
+	body := `
+		<h1>hello</h1>
+		<div color="red">
+			this is send from 163.com
+		</div>
+	`
+	err := smtp.Send([]string{"wedtrav@foxmail.com"}, "hello", body)
+	AssertNil(err, "send mail", t)
+}

utl/string_test.go

@@ -1 +1,14 @@
 package utl
+
+import (
+	"testing"
+)
+
+func TestStringToBytes(t *testing.T) {
+	var f string = "god"
+	b := StringToBytes(f)
+	AssertTrue(string(b) == f, "god==god", t)
+
+	ff := BytesToString(b)
+	AssertTrue(ff == f, "gods == gods", t)
+}

utl/test.go

@@ -0,0 +1,30 @@
+package utl
+
+import (
+	"testing"
+)
+
+func AssertTrue(condition bool, msg string, t *testing.T) {
+	if !condition {
+		t.Fatal(msg)
+	}
+}
+
+func AssertFalse(cond bool, msg string, t *testing.T) {
+	if cond {
+		t.Fatal(cond)
+	}
+}
+
+func AssertNil(err error, msg string, t *testing.T) {
+	if err != nil {
+		t.Log(msg)
+		t.Fatal(err)
+	}
+}
+
+func AssertErr(err error, msg string, t *testing.T) {
+	if err == nil {
+		t.Fatal(msg)
+	}
+}

utl/tokenizer.go

@@ -23,9 +23,9 @@ func (self *Tokenizer) Gen(kvs map[string]interface{}) (string, error) {
 	for k, v := range kvs {
 		clm[k] = v
 	}
-	clm["exp"] = time.Now().Add(self.lasts)
+	clm["exp"] = time.Now().Add(self.lasts).Unix()
 	tok := jwt.NewWithClaims(jwt.SigningMethodHS512, clm)
-	return tok.SignedString(self.key)
+	return tok.SignedString([]byte(self.key))
 }
 
 func (self *Tokenizer) Parse(tokenstr string) (jwt.MapClaims, error) {
@@ -33,7 +33,7 @@ func (self *Tokenizer) Parse(tokenstr string) (jwt.MapClaims, error) {
 		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
 			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
 		}
-		return self.key, nil
+		return []byte(self.key), nil
 	})
 	if err != nil {
 		return nil, err

utl/tokenizer_test.go

@@ -1 +1,20 @@
 package utl
+
+import (
+	"testing"
+	"time"
+)
+
+func TestTokenizer(t *testing.T) {
+	tn := NewTokenizer("123455", 2*time.Minute)
+
+	token, err := tn.Gen(map[string]interface{}{"id": 123})
+	AssertNil(err, "gen token", t)
+
+	t.Log(token)
+	c, err := tn.Parse(token)
+	AssertNil(err, "parse token", t)
+	for k, v := range c {
+		t.Log(k, "=", v)
+	}
+}

utl/validators_test.go

@@ -15,11 +15,27 @@ func TestIsPhone(t *testing.T) {
 		"19200001111",
 	}
 
-	for _, phone := range phones {
-		b := IsPhoneSimple(phone)
-		t.Log(phone, "=", b)
-		bs := IsPhone(phone)
-		t.Log(phone, "=", bs)
-	}
+	var b, bs bool
+	var phone string
+	phone = phones[0]
+	bs, b = IsPhoneSimple(phone), IsPhone(phone)
+	AssertFalse(bs, phone + " should not be phone", t)
+	AssertFalse(b, phone + " should not be phone", t)
+
+	phone = phones[1]
+	bs, b = IsPhoneSimple(phone), IsPhone(phone)
+	AssertTrue(bs, phone + " should be phone", t)
+	AssertFalse(b, phone + " should not be phone", t)
+}
+
+func TestIsEmail(t *testing.T) {
+
 }
 
+func TestIsAlpha(t *testing.T) {
+
+}
+
+func TestIsSafePasswd(t *testing.T) {
+
+}

utl/workerPool_test.go

@@ -1,25 +1,19 @@
 package utl
 
 import (
-	"os"
-	"os/signal"
-	"syscall"
 	"testing"
 	"time"
 )
 
 func TestWorkPool_Put(t *testing.T) {
-	p := NewWorkPool(16)
+	p := NewWorkPool(WithWorkPoolSize(16))
 
-	num := 100
+	num := 2
 	for num > 0 {
-		p.Put(func(timer *time.Timer){
+		p.Put(func(timer *time.Timer) {
 			time.Sleep(0 * time.Second)
-			t.Log("in func")
 		})
 		num = num - 1
 	}
-	sig := make(chan os.Signal)
-	signal.Notify(sig, syscall.SIGINT)
-	t.Log(<-sig)
-}
+	time.Sleep(time.Second)
+}