杭州明婳科技
114 lines
3.5 KiB
Go
114 lines
3.5 KiB
Go
package cache
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/EthanCodeCraft/xlgo-core/database"
|
|
"github.com/alicebob/miniredis/v2"
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
func setupM10MiniRedis(t *testing.T) *miniredis.Miniredis {
|
|
t.Helper()
|
|
mr := miniredis.RunT(t)
|
|
client := redis.NewClient(&redis.Options{Addr: mr.Addr()})
|
|
t.Cleanup(func() { _ = client.Close() })
|
|
database.SetTestRedisClient(client)
|
|
t.Cleanup(func() { database.SetTestRedisClient(nil) })
|
|
return mr
|
|
}
|
|
|
|
func TestM10CacheWritesReturnRedisNotReady(t *testing.T) {
|
|
database.SetTestRedisClient(nil)
|
|
t.Cleanup(func() { database.SetTestRedisClient(nil) })
|
|
|
|
c := &redisCache{}
|
|
ctx := context.Background()
|
|
|
|
if err := c.Set(ctx, "k", "v", time.Minute); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("Set without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if err := c.Delete(ctx, "k"); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("Delete without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if err := c.DeleteByPattern(ctx, "k:*"); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("DeleteByPattern without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
}
|
|
|
|
func TestM10RawHelpersReturnRedisNotReady(t *testing.T) {
|
|
database.SetTestRedisClient(nil)
|
|
t.Cleanup(func() { database.SetTestRedisClient(nil) })
|
|
ctx := context.Background()
|
|
|
|
if _, err := Incr(ctx, "k"); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("Incr without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if _, err := IncrBy(ctx, "k", 2); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("IncrBy without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if _, err := Decr(ctx, "k"); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("Decr without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if _, err := GetTTL(ctx, "k"); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("GetTTL without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if _, err := SetExpire(ctx, "k", time.Minute); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("SetExpire without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if _, err := GetRaw(ctx, "k"); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("GetRaw without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
if err := SetRaw(ctx, "k", "v", time.Minute); !errors.Is(err, ErrRedisNotReady) {
|
|
t.Fatalf("SetRaw without Redis err = %v, want ErrRedisNotReady", err)
|
|
}
|
|
}
|
|
|
|
func TestM10ExistsEReturnsBackendErrors(t *testing.T) {
|
|
setupM10MiniRedis(t)
|
|
c := &redisCache{}
|
|
ctx := context.Background()
|
|
|
|
exists, err := c.ExistsE(ctx, "missing")
|
|
if err != nil {
|
|
t.Fatalf("ExistsE missing err = %v", err)
|
|
}
|
|
if exists {
|
|
t.Fatal("ExistsE missing = true, want false")
|
|
}
|
|
|
|
if err := c.Set(ctx, "present", "value", time.Minute); err != nil {
|
|
t.Fatalf("Set present: %v", err)
|
|
}
|
|
exists, err = c.ExistsE(ctx, "present")
|
|
if err != nil || !exists {
|
|
t.Fatalf("ExistsE present = %v, err=%v; want true,nil", exists, err)
|
|
}
|
|
|
|
canceled, cancel := context.WithCancel(ctx)
|
|
cancel()
|
|
if exists, err = c.ExistsE(canceled, "present"); err == nil || exists {
|
|
t.Fatalf("ExistsE canceled = %v, err=%v; want false,error", exists, err)
|
|
}
|
|
}
|
|
|
|
func TestM10PackageExistsEUsesOptionalInterface(t *testing.T) {
|
|
setupM10MiniRedis(t)
|
|
orig := GetDefaultCache()
|
|
t.Cleanup(func() { SetDefaultCacheManager(orig) })
|
|
SetDefaultCacheManager(NewCacheManager())
|
|
Init()
|
|
|
|
ctx := context.Background()
|
|
if err := GetCache().Set(ctx, "present", "value", time.Minute); err != nil {
|
|
t.Fatalf("Set through facade: %v", err)
|
|
}
|
|
exists, err := ExistsE(ctx, "present")
|
|
if err != nil || !exists {
|
|
t.Fatalf("facade ExistsE = %v, err=%v; want true,nil", exists, err)
|
|
}
|
|
}
|