fixed simple cache

Author: Code-Hex

cache.go

@@ -9,6 +9,9 @@ import (
 type Cache[K comparable, V any] interface {
 	Get(key K) (value V, ok bool)
 	Set(key K, val V, opts ...ItemOption)
+	Keys() []K
+	Delete(key K)
+	Contains(key K) bool
 }
 
 // Item is an item

lru/lru_test.go

@@ -62,5 +62,4 @@ func TestDelete(t *testing.T) {
 	if _, ok := cache.Get("foo"); ok {
 		t.Fatalf("invalid get after deleted %v", ok)
 	}
-
 }

simple/example_test.go

@@ -2,7 +2,6 @@ package simple_test
 
 import (
 	"fmt"
-	"sort"
 	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
@@ -19,24 +18,29 @@ func ExampleCache() {
 	fmt.Println(av, aok)
 	fmt.Println(bv, bok)
 	fmt.Println(cv, cok)
+	c.Delete("a")
+	_, aok2 := c.Get("a")
+	if !aok2 {
+		fmt.Println("key 'a' has been deleted")
+	}
 	// Output:
 	// 1 true
 	// 2 true
 	// 0 false
+	// key 'a' has been deleted
 }
 
 func ExampleCacheKeys() {
 	c := simple.NewCache[string, int]()
-	c.Set("a", 1)
-	c.Set("b", 2)
-	c.Set("c", 3)
+	c.Set("foo", 1)
+	c.Set("bar", 2)
+	c.Set("baz", 3)
 	keys := c.Keys()
-	sort.Strings(keys)
 	for _, key := range keys {
 		fmt.Println(key)
 	}
 	// Output:
-	// a
-	// b
-	// c
+	// foo
+	// bar
+	// baz
 }

simple/simple.go

@@ -1,6 +1,7 @@
 package simple
 
 import (
+	"sort"
 	"sync"
 
 	cache "github.com/Code-Hex/go-generics-cache"
@@ -45,11 +46,37 @@ func (c *Cache[K, V]) Get(k K) (val V, ok bool) {
 	return got.Value, true
 }
 
-// Keys returns cache keys. the order is random.
+// Keys returns cache keys. the order is sorted by created.
 func (c *Cache[K, _]) Keys() []K {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
 	ret := make([]K, 0, len(c.items))
 	for key := range c.items {
 		ret = append(ret, key)
 	}
+	sort.Slice(ret, func(i, j int) bool {
+		i1 := c.items[ret[i]]
+		i2 := c.items[ret[j]]
+		return i1.CreatedAt.Before(i2.CreatedAt)
+	})
 	return ret
 }
+
+// Delete deletes the item with provided key from the cache.
+func (c *Cache[K, V]) Delete(key K) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	delete(c.items, key)
+}
+
+// Contains reports whether key is within cache.
+func (c *Cache[K, V]) Contains(key K) bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	item, ok := c.items[key]
+	if !ok {
+		return false
+	}
+	return !item.HasExpired()
+}

simple/simple_internal_test.go

@@ -0,0 +1,67 @@
+package simple
+
+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
+		item, ok := c.items[key]
+		if !ok {
+			t.Fatal("unexpected not found key")
+		}
+		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
+	item, ok := c.items[key]
+	if !ok {
+		t.Fatal("unexpected not found key")
+	}
+	item.CreatedAt = time.Now().Add(-2 * exp)
+	_, ok2 := c.Get(key)
+	if ok2 {
+		t.Fatal("unexpected found (expired)")
+	}
+}