Merge pull request #6 from Code-Hex/fix/item-behavior

fixed item behavior

Author: Code-Hex

cache.go

@@ -2,12 +2,63 @@ package cache
 
 import (
 	"sync"
+	"time"
 )
 
 // Cache is a common-cache interface.
 type Cache[K comparable, V any] interface {
 	Get(key K) (value V, ok bool)
-	Set(key K, val V)
+	Set(key K, val V, opts ...ItemOption)
+	Keys() []K
+	Delete(key K)
+	Contains(key K) bool
+}
+
+// Item is an item
+type Item[K comparable, V any] struct {
+	Key        K
+	Value      V
+	Expiration time.Duration
+	CreatedAt  time.Time
+}
+
+var nowFunc = time.Now
+
+// HasExpired returns true if the item has expired.
+// If the item's expiration is zero value, returns false.
+func (i Item[K, T]) HasExpired() bool {
+	if i.Expiration <= 0 {
+		return false
+	}
+	return i.CreatedAt.Add(i.Expiration).Before(nowFunc())
+}
+
+// ItemOption is an option for cache item.
+type ItemOption func(*itemOptions)
+
+type itemOptions struct {
+	expiration time.Duration // default none
+}
+
+// WithExpiration is an option to set expiration time for any items.
+func WithExpiration(exp time.Duration) ItemOption {
+	return func(o *itemOptions) {
+		o.expiration = exp
+	}
+}
+
+// NewItem creates a new item with specified any options.
+func NewItem[K comparable, V any](key K, val V, opts ...ItemOption) *Item[K, V] {
+	o := new(itemOptions)
+	for _, optFunc := range opts {
+		optFunc(o)
+	}
+	return &Item[K, V]{
+		Key:        key,
+		Value:      val,
+		Expiration: o.expiration,
+		CreatedAt:  nowFunc(),
+	}
 }
 
 // NumberCache is a in-memory cache which is able to store only Number constraint.

cache_test.go

@@ -3,6 +3,7 @@ package cache_test
 import (
 	"sync"
 	"testing"
+	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
 	"github.com/Code-Hex/go-generics-cache/simple"
@@ -49,3 +50,54 @@ func TestMultiThreadDecr(t *testing.T) {
 		t.Errorf("want %v but got %v", 0, counter)
 	}
 }
+
+func TestHasExpired(t *testing.T) {
+	cases := []struct {
+		name      string
+		exp       time.Duration
+		createdAt time.Time
+		current   time.Time
+		want      bool
+	}{
+		// expiration == createdAt + exp
+		{
+			name: "item expiration is zero",
+			want: false,
+		},
+		{
+			name:      "item expiration > current time",
+			exp:       time.Hour * 24,
+			createdAt: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			current:   time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			want:      false,
+		},
+		{
+			name:      "item expiration < current time",
+			exp:       time.Hour * 24,
+			createdAt: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			current:   time.Date(2009, time.November, 12, 23, 0, 0, 0, time.UTC),
+			want:      true,
+		},
+		{
+			name:      "item expiration == current time",
+			exp:       time.Second,
+			createdAt: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			current:   time.Date(2009, time.November, 10, 23, 0, 1, 0, time.UTC),
+			want:      false,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			reset := cache.SetNowFunc(tc.current)
+			defer reset()
+
+			it := &cache.Item[int, int]{
+				Expiration: tc.exp,
+				CreatedAt:  tc.createdAt,
+			}
+			if got := it.HasExpired(); tc.want != got {
+				t.Fatalf("want %v, but got %v", tc.want, got)
+			}
+		})
+	}
+}

example_test.go

@@ -2,24 +2,26 @@ package cache_test
 
 import (
 	"fmt"
+	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
 	"github.com/Code-Hex/go-generics-cache/simple"
 )
 
 func ExampleNumberCache() {
-	c := cache.NewNumber[string, int](simple.NewCache[string, int]())
-	c.Set("a", 1)
-	c.Set("b", 2)
-	av := c.Increment("a", 1)
-	gota, aok := c.Get("a")
+	c := simple.NewCache[string, int]()
+	nc := cache.NewNumber[string, int](c)
+	nc.Set("a", 1)
+	nc.Set("b", 2, cache.WithExpiration(time.Minute))
+	av := nc.Increment("a", 1)
+	gota, aok := nc.Get("a")
 
-	bv := c.Decrement("b", 1)
-	gotb, bok := c.Get("b")
+	bv := nc.Decrement("b", 1)
+	gotb, bok := nc.Get("b")
 
 	// not set keys
-	cv := c.Increment("c", 100)
-	dv := c.Decrement("d", 100)
+	cv := nc.Increment("c", 100)
+	dv := nc.Decrement("d", 100)
 	fmt.Println(av, gota, aok)
 	fmt.Println(bv, gotb, bok)
 	fmt.Println(cv)

export_test.go

@@ -0,0 +1,11 @@
+package cache
+
+import "time"
+
+func SetNowFunc(tm time.Time) (reset func()) {
+	backup := nowFunc
+	nowFunc = func() time.Time { return tm }
+	return func() {
+		nowFunc = backup
+	}
+}

lru/lru.go

@@ -17,11 +17,6 @@ type Cache[K comparable, V any] struct {
 
 var _ cache.Cache[interface{}, any] = (*Cache[interface{}, any])(nil)
 
-type item[K comparable, V any] struct {
-	Key   K
-	Value V
-}
-
 // NewCache creates a new LRU cache whose capacity is the default size (128).
 func NewCache[K comparable, V any]() *Cache[K, V] {
 	return NewCacheWithCap[K, V](128)
@@ -32,38 +27,41 @@ func NewCacheWithCap[K comparable, V any](cap int) *Cache[K, V] {
 	return &Cache[K, V]{
 		cap:   cap,
 		list:  list.New(),
-		items: make(map[K]*list.Element),
+		items: make(map[K]*list.Element, cap),
 	}
 }
 
 // Get looks up a key's value from the cache.
 func (c *Cache[K, V]) Get(key K) (zero V, _ bool) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-	if e, ok := c.items[key]; ok {
-		// updates cache order
-		c.list.MoveToFront(e)
-		return e.Value.(*item[K, V]).Value, true
+	e, ok := c.items[key]
+	if !ok {
+		return
+	}
+	item := e.Value.(*cache.Item[K, V])
+	if item.HasExpired() {
+		return
 	}
-	return
+	// updates cache order
+	c.list.MoveToFront(e)
+	return item.Value, true
 }
 
 // Set sets a value to the cache with key. replacing any existing value.
-func (c *Cache[K, V]) Set(key K, val V) {
+func (c *Cache[K, V]) Set(key K, val V, opts ...cache.ItemOption) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
 	if e, ok := c.items[key]; ok {
 		// updates cache order
 		c.list.MoveToFront(e)
-		e.Value.(*item[K, V]).Value = val
+		e.Value.(*cache.Item[K, V]).Value = val
 		return
 	}
 
-	e := c.list.PushFront(&item[K, V]{
-		Key:   key,
-		Value: val,
-	})
+	item := cache.NewItem(key, val, opts...)
+	e := c.list.PushFront(item)
 	c.items[key] = e
 
 	if c.list.Len() > c.cap {
@@ -77,7 +75,8 @@ func (c *Cache[K, V]) Keys() []K {
 	defer c.mu.RUnlock()
 	keys := make([]K, 0, len(c.items))
 	for ent := c.list.Back(); ent != nil; ent = ent.Prev() {
-		keys = append(keys, ent.Value.(*item[K, V]).Key)
+		item := ent.Value.(*cache.Item[K, V])
+		keys = append(keys, item.Key)
 	}
 	return keys
 }
@@ -102,8 +101,12 @@ func (c *Cache[K, V]) Delete(key K) {
 func (c *Cache[K, V]) Contains(key K) bool {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-	_, ok := c.items[key]
-	return ok
+	e, ok := c.items[key]
+	if !ok {
+		return false
+	}
+	item := e.Value.(*cache.Item[K, V])
+	return !item.HasExpired()
 }
 
 func (c *Cache[K, V]) deleteOldest() {
@@ -113,6 +116,6 @@ func (c *Cache[K, V]) deleteOldest() {
 
 func (c *Cache[K, V]) delete(e *list.Element) {
 	c.list.Remove(e)
-	item := e.Value.(*item[K, V])
+	item := e.Value.(*cache.Item[K, V])
 	delete(c.items, item.Key)
 }

lru/lru_internal_test.go

@@ -0,0 +1,69 @@
+package lru
+
+import (
+	"testing"
+	"time"
+
+	cache "github.com/Code-Hex/go-generics-cache"
+)
+
+func TestContains(t *testing.T) {
+	t.Run("without expiration", func(t *testing.T) {
+		cache := NewCache[string, int]()
+		cache.Set("foo", 1)
+		cache.Set("bar", 2)
+		cache.Set("baz", 3)
+		for _, key := range []string{
+			"foo",
+			"bar",
+			"baz",
+		} {
+			if !cache.Contains(key) {
+				t.Errorf("not found: %s", key)
+			}
+		}
+		if cache.Contains("not found") {
+			t.Errorf("found")
+		}
+	})
+
+	t.Run("with expiration", func(t *testing.T) {
+		c := NewCache[string, int]()
+		key := "foo"
+		exp := time.Hour
+		c.Set(key, 1, cache.WithExpiration(exp))
+		// modify directly
+		e, ok := c.items[key]
+		if !ok {
+			t.Fatal("unexpected not found key")
+		}
+		item := e.Value.(*cache.Item[string, int])
+		item.CreatedAt = time.Now().Add(-2 * exp)
+
+		if c.Contains(key) {
+			t.Errorf("found")
+		}
+	})
+}
+
+func TestGet(t *testing.T) {
+	c := NewCache[string, int]()
+	key := "foo"
+	exp := time.Hour
+	c.Set(key, 1, cache.WithExpiration(exp))
+	_, ok := c.Get(key)
+	if !ok {
+		t.Fatal("unexpected not found")
+	}
+	// modify directly
+	e, ok := c.items[key]
+	if !ok {
+		t.Fatal("unexpected not found key")
+	}
+	item := e.Value.(*cache.Item[string, int])
+	item.CreatedAt = time.Now().Add(-2 * exp)
+	_, ok2 := c.Get(key)
+	if ok2 {
+		t.Fatal("unexpected found (expired)")
+	}
+}

lru/lru_test.go

@@ -43,22 +43,6 @@ func TestSet(t *testing.T) {
 	}
 }
 
-func TestContains(t *testing.T) {
-	cache := lru.NewCache[string, int]()
-	cache.Set("foo", 1)
-	cache.Set("bar", 2)
-	cache.Set("baz", 3)
-	for _, key := range []string{
-		"foo",
-		"bar",
-		"baz",
-	} {
-		if !cache.Contains(key) {
-			t.Errorf("not found: %s", key)
-		}
-	}
-}
-
 func TestDelete(t *testing.T) {
 	cache := lru.NewCacheWithCap[string, int](1)
 	cache.Set("foo", 1)
@@ -78,5 +62,4 @@ func TestDelete(t *testing.T) {
 	if _, ok := cache.Get("foo"); ok {
 		t.Fatalf("invalid get after deleted %v", ok)
 	}
-
 }