baize/test/cache_test.go

package test

import (
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/cache"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/cache/local"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/cache/redis"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/pkg/errors"
	"testing"
	"time"
)

func TestLocalCache(t *testing.T) {
	localhostCache := local.New("test")
	testLocalCache(t, localhostCache)
}

func TestRedisCache(t *testing.T) {
	redisCache, err := redis.New("localhost:6379", "", "mtyzxhc", 1, "test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}
	defer func() {
		err := redis.Destroy(redisCache)
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	testRedisCache(t, redisCache)
}

func TestCacheInfrastructure(t *testing.T) {
	i := infrastructure.NewInfrastructure(infrastructure.Config{
		CacheConfig: infrastructure.CacheConfig{
			Namespace: "test",
			Redis: &infrastructure.RedisConfig{
				Address:  "localhost:6379",
				UserName: "",
				Password: "mtyzxhc",
				DB:       1,
			},
		},
	})
	defer infrastructure.DestroyInfrastructure(i)

	testCache(t, i.LocalCache())
	testCache(t, i.RedisCache())
}

func TestCacheExpire(t *testing.T) {
	i := infrastructure.NewInfrastructure(infrastructure.Config{
		CacheConfig: infrastructure.CacheConfig{
			Namespace: "test",
			Redis: &infrastructure.RedisConfig{
				Address:  "localhost:6379",
				UserName: "",
				Password: "mtyzxhc",
				DB:       1,
			},
		},
	})
	defer infrastructure.DestroyInfrastructure(i)

	testCacheExpire(t, i.LocalCache())
	testCacheExpire(t, i.RedisCache())
}

func testLocalCache(t *testing.T, localCache *local.Cache) {
	err := localCache.Set("test1", "test1-value", 0)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	test1Value, err := localCache.Get("test1")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if test1Value != "test1-value" {
		t.Fatalf("Value Error: cache %v\n", test1Value)
	}

	err = localCache.Set("test2", "test2-value", 0)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	multiValues, err := localCache.GetMulti([]string{"test1", "test2"})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(multiValues) != 2 {
		t.Fatalf("Value Error: cache %v\n", multiValues)
	}

	if multiValues["test1"] != "test1-value" || multiValues["test2"] != "test2-value" {
		t.Fatalf("Value Error: cache %v\n", multiValues)
	}

	allValues, err := localCache.GetAll()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(allValues) != 2 {
		t.Fatalf("Value Error: cache %v\n", allValues)
	}

	if allValues["test1"] != "test1-value" || allValues["test2"] != "test2-value" {
		t.Fatalf("Value Error: cache %v\n", allValues)
	}

	err = localCache.Delete("test2")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	test2Value, err := localCache.Get("test2")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(test2Value) {
		t.Fatalf("Delete Value Error: cache %v\n", test2Value)
	}

	err = localCache.Clear()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	allValues, err = localCache.GetAll()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(allValues) != 0 {
		t.Fatalf("Clear Value Error: cache %v\n", allValues)
	}

	err = localCache.Set("test", "test-value", 1)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	time.Sleep(1500 * time.Millisecond)

	testValue, err := localCache.Get("test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(testValue) {
		t.Fatalf("Value Expire Error: cache %v\n", testValue)
	}

	err = localCache.Clear()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}
}

func testRedisCache(t *testing.T, redisCache *redis.Cache) {
	err := redisCache.Set("test1", "test1-value", 0)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	test1Value, err := redisCache.Get("test1")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if test1Value != "test1-value" {
		t.Fatalf("Value Error: cache %v\n", test1Value)
	}

	err = redisCache.Set("test2", "test2-value", 0)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	multiValues, err := redisCache.GetMulti([]string{"test1", "test2"})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(multiValues) != 2 {
		t.Fatalf("Value Error: cache %v\n", multiValues)
	}

	if multiValues["test1"] != "test1-value" || multiValues["test2"] != "test2-value" {
		t.Fatalf("Value Error: cache %v\n", multiValues)
	}

	allValues, err := redisCache.GetAll()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(allValues) != 2 {
		t.Fatalf("Value Error: cache %v\n", allValues)
	}

	if allValues["test1"] != "test1-value" || allValues["test2"] != "test2-value" {
		t.Fatalf("Value Error: cache %v\n", allValues)
	}

	err = redisCache.Delete("test2")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	test2Value, err := redisCache.Get("test2")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(test2Value) {
		t.Fatalf("Delete Value Error: cache %v\n", test2Value)
	}

	err = redisCache.Clear()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	allValues, err = redisCache.GetAll()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(allValues) != 0 {
		t.Fatalf("Clear Value Error: cache %v\n", allValues)
	}

	err = redisCache.Set("test", "test-value", 1)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	time.Sleep(1500 * time.Millisecond)

	testValue, err := redisCache.Get("test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(testValue) {
		t.Fatalf("Value Expire Error: cache %v\n", testValue)
	}

	err = redisCache.Clear()
	if err != nil {
		t.Fatalf("%+v\n", err)
	}
}

func testCache(t *testing.T, cacheInterface cache.Cache) {
	err := cache.Set(cacheInterface, "test1", "test1-value", 0)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	test1Value, err := cache.Get[string](cacheInterface, "test1")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if test1Value != "test1-value" {
		t.Fatalf("Value Error: cache %v\n", test1Value)
	}

	err = cache.Set(cacheInterface, "test2", "test2-value", 0)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	multiValues, err := cache.GetMulti(cacheInterface, []string{"test1", "test2"})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(multiValues) != 2 {
		t.Fatalf("Value Error: cache %v\n", multiValues)
	}

	if multiValues["test1"] != "test1-value" || multiValues["test2"] != "test2-value" {
		t.Fatalf("Value Error: cache %v\n", multiValues)
	}

	allValues, err := cache.GetAll(cacheInterface)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(allValues) != 2 {
		t.Fatalf("Value Error: cache %v\n", allValues)
	}

	if allValues["test1"] != "test1-value" || allValues["test2"] != "test2-value" {
		t.Fatalf("Value Error: cache %v\n", allValues)
	}

	err = cache.Delete(cacheInterface, "test2")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	test2Value, err := cache.Get[string](cacheInterface, "test2")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(test2Value) {
		t.Fatalf("Delete Value Error: cache %v\n", test2Value)
	}

	err = cache.Clear(cacheInterface)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	allValues, err = cache.GetAll(cacheInterface)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(allValues) != 0 {
		t.Fatalf("Clear Value Error: cache %v\n", allValues)
	}

	err = cache.Set(cacheInterface, "test", "test-value", 1)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	time.Sleep(1500 * time.Millisecond)

	testValue, err := cache.Get[string](cacheInterface, "test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(testValue) {
		t.Fatalf("Value Expire Error: cache %v\n", testValue)
	}

	err = cache.Clear(cacheInterface)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}
}

func testCacheExpire(t *testing.T, cacheInterface cache.Cache) {
	err := cache.Set(cacheInterface, "test", 10, 1)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	time.Sleep(2 * time.Second)

	value, err := cache.Get[string](cacheInterface, "test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(value) {
		t.Fatalf("%+v\n", errors.Errorf("Value Expire Error: cache %v", value))
	}

	err = cache.Set(cacheInterface, "test", 10, 0)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	err = cache.Expire(cacheInterface, "test", 1)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	time.Sleep(2 * time.Second)

	value, err = cache.Get[string](cacheInterface, "test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(value) {
		t.Fatalf("%+v\n", errors.Errorf("Value Expire Error: cache %v", value))
	}

	err = cache.Set(cacheInterface, "test", 10, 5)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	err = cache.Expire(cacheInterface, "test", 1)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	time.Sleep(2 * time.Second)

	value, err = cache.Get[string](cacheInterface, "test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if strutils.IsStringNotEmpty(value) {
		t.Fatalf("%+v\n", errors.Errorf("Value Expire Error: cache %v", value))
	}

	err = cache.Set(cacheInterface, "test", 10, 10)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	err = cache.Expire(cacheInterface, "test", 5)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	ttl, err := cache.TTL(cacheInterface, "test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if ttl != 5 {
		t.Fatalf("%+v\n", errors.Errorf("TTL Error: ttl %v", ttl))
	}

	err = cache.Delete(cacheInterface, "test")
	if err != nil {
		t.Fatalf("%+v\n", err)
	}
}