Merge pull request #64 from UnderTreeTech/enhancement/test_coverage

add ip unit test

docs/COPYRIGHT.txt

@@ -0,0 +1,17 @@
+/*
+ *
+ * Copyright 2020 waterdrop authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */

pkg/log/log_test.go

@@ -21,6 +21,8 @@ package log
 import (
 	"context"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLog(t *testing.T) {
@@ -40,7 +42,29 @@ func TestLog(t *testing.T) {
 		String("shanghai", "xuhui"),
 	)
 
-	Error(context.Background(), "division zero") //KVString("shanghai", "xuhui"),
+	Error(context.Background(), "division zero", String("shanghai", "xuhui"))
+
+	assert.Panics(t, func() {
+		Panic(context.Background(), "memory leaky", String("stop", "yes"))
+	})
+
+	Infof("info",
+		Int64("age", 10),
+		String("hello", "world"),
+		Any("any", []string{"shanghai", "xuhui"}),
+	)
+
+	Warnf("warn",
+		String("john", "sun"),
+	)
+
+	Debugf("debug",
+		String("shanghai", "xuhui"),
+	)
+
+	Errorf("division zero", String("shanghai", "xuhui"))
 
-	//Panic(context.Background(), "memory leaky", String("stop", "yes"))
+	assert.Panics(t, func() {
+		Panicf("memory leaky", String("stop", "yes"))
+	})
 }

pkg/server/http/client/client.go

@@ -87,7 +87,7 @@ func (c *Client) NewRequest(ctx context.Context, method string, req *Request, re
 	request.SetResult(reply)
 
 	if c.config.EnableSign {
-		ts := strconv.Itoa(int(xtime.GetCurrentUnixTime()))
+		ts := strconv.Itoa(int(xtime.Now().CurrentUnixTime()))
 		nonce := xstring.RandomString(md.DefaultNonceLen)
 		sign, err := c.sign(ctx, method, ts, nonce, req)
 		if err != nil {

pkg/utils/xcollection/lru.go

@@ -0,0 +1,133 @@
+/*
+ *
+ * Copyright 2020 waterdrop authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package xcollection
+
+import "container/list"
+
+// Cache is an LRU cache. It is not safe for concurrent access.
+type LRUCache struct {
+	// MaxEntries is the maximum number of cache entries before
+	// an item is evicted. Zero means no limit.
+	MaxEntries int
+
+	// OnEvicted optionally specifies a callback function to be
+	// executed when an entry is purged from the cache.
+	OnEvicted func(key Key, value interface{})
+
+	ll    *list.List
+	cache map[interface{}]*list.Element
+}
+
+type Key interface{}
+
+type entry struct {
+	key   Key
+	value interface{}
+}
+
+// New creates a new Cache.
+// If maxEntries is zero, the cache has no limit and it's assumed
+// that eviction is done by the caller.
+func NewLRU(maxEntries int) *LRUCache {
+	return &LRUCache{
+		MaxEntries: maxEntries,
+		ll:         list.New(),
+		cache:      make(map[interface{}]*list.Element),
+	}
+}
+
+// Add adds a value to the cache.
+func (c *LRUCache) Add(key Key, value interface{}) {
+	if c.cache == nil {
+		c.cache = make(map[interface{}]*list.Element)
+		c.ll = list.New()
+	}
+	if ee, ok := c.cache[key]; ok {
+		c.ll.MoveToFront(ee)
+		ee.Value.(*entry).value = value
+		return
+	}
+	ele := c.ll.PushFront(&entry{key, value})
+	c.cache[key] = ele
+	if c.MaxEntries != 0 && c.ll.Len() > c.MaxEntries {
+		c.RemoveOldest()
+	}
+}
+
+// Get looks up a key's value from the cache.
+func (c *LRUCache) Get(key Key) (value interface{}, ok bool) {
+	if c.cache == nil {
+		return
+	}
+	if ele, hit := c.cache[key]; hit {
+		c.ll.MoveToFront(ele)
+		return ele.Value.(*entry).value, true
+	}
+	return
+}
+
+// Remove removes the provided key from the cache.
+func (c *LRUCache) Remove(key Key) {
+	if c.cache == nil {
+		return
+	}
+	if ele, hit := c.cache[key]; hit {
+		c.removeElement(ele)
+	}
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *LRUCache) RemoveOldest() {
+	if c.cache == nil {
+		return
+	}
+	ele := c.ll.Back()
+	if ele != nil {
+		c.removeElement(ele)
+	}
+}
+
+func (c *LRUCache) removeElement(e *list.Element) {
+	c.ll.Remove(e)
+	kv := e.Value.(*entry)
+	delete(c.cache, kv.key)
+	if c.OnEvicted != nil {
+		c.OnEvicted(kv.key, kv.value)
+	}
+}
+
+// Len returns the number of items in the cache.
+func (c *LRUCache) Len() int {
+	if c.cache == nil {
+		return 0
+	}
+	return c.ll.Len()
+}
+
+// Clear purges all stored items from the cache.
+func (c *LRUCache) Clear() {
+	if c.OnEvicted != nil {
+		for _, e := range c.cache {
+			kv := e.Value.(*entry)
+			c.OnEvicted(kv.key, kv.value)
+		}
+	}
+	c.ll = nil
+	c.cache = nil
+}

pkg/utils/xcollection/lru_test.go

@@ -0,0 +1,106 @@
+/*
+ *
+ * Copyright 2020 waterdrop authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package xcollection
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/go-playground/assert/v2"
+)
+
+type simpleStruct struct {
+	int
+	string
+}
+
+type complexStruct struct {
+	int
+	simpleStruct
+}
+
+var getTests = []struct {
+	name       string
+	keyToAdd   interface{}
+	keyToGet   interface{}
+	expectedOk bool
+}{
+	{"string_hit", "myKey", "myKey", true},
+	{"string_miss", "myKey", "nonsense", false},
+	{"simple_struct_hit", simpleStruct{1, "two"}, simpleStruct{1, "two"}, true},
+	{"simple_struct_miss", simpleStruct{1, "two"}, simpleStruct{0, "noway"}, false},
+	{"complex_struct_hit", complexStruct{1, simpleStruct{2, "three"}},
+		complexStruct{1, simpleStruct{2, "three"}}, true},
+}
+
+func TestGet(t *testing.T) {
+	lru := NewLRU(0)
+	for _, tt := range getTests {
+		lru.Add(tt.keyToAdd, 1234)
+		_, ok := lru.Get(tt.keyToGet)
+		assert.Equal(t, ok, tt.expectedOk)
+	}
+}
+
+func TestRemove(t *testing.T) {
+	lru := NewLRU(0)
+	lru.Add("myKey", 1234)
+	val, ok := lru.Get("myKey")
+	assert.Equal(t, true, ok)
+	assert.Equal(t, 1234, val.(int))
+
+	lru.Remove("myKey")
+	_, ok = lru.Get("myKey")
+	assert.Equal(t, false, ok)
+}
+
+func TestEvict(t *testing.T) {
+	evictedKeys := make([]Key, 0)
+	onEvictedFun := func(key Key, value interface{}) {
+		evictedKeys = append(evictedKeys, key)
+	}
+
+	lru := NewLRU(20)
+	lru.OnEvicted = onEvictedFun
+	for i := 0; i < 22; i++ {
+		lru.Add(fmt.Sprintf("myKey%d", i), 1234)
+	}
+
+	assert.Equal(t, 2, len(evictedKeys))
+	assert.Equal(t, evictedKeys[0], Key("myKey0"))
+	assert.Equal(t, evictedKeys[1], Key("myKey1"))
+}
+
+func TestClear(t *testing.T) {
+	lru := NewLRU(20)
+	for i := 0; i < 22; i++ {
+		lru.Add(fmt.Sprintf("myKey%d", i), 1234)
+	}
+	lru.Clear()
+	assert.Equal(t, lru.ll, nil)
+	assert.Equal(t, lru.cache, nil)
+}
+
+func TestLRULen(t *testing.T) {
+	lru := NewLRU(20)
+	for i := 0; i < 22; i++ {
+		lru.Add(fmt.Sprintf("myKey%d", i), 1234)
+	}
+	assert.Equal(t, lru.Len(), 20)
+}