Function TestSmallTTLOnBigPayloadAreCacheWithFile

cache/redis_cache_test.go:223–272

(t *testing.T)

}

func TestSmallTTLOnBigPayloadAreCacheWithFile(t *testing.T) {
	cache, redis := getRedisCacheAndServer(t)
	defer cache.Close()
	key := &Key{
		Query: []byte(fmt.Sprintf("SELECT test")),
	}
	payloadSize := 4 * 1024 * 1024
	expectedValue := strings.Repeat("a", payloadSize)
	reader := strings.NewReader(expectedValue)

	if _, err := cache.Put(reader, ContentMetadata{Encoding: "ce", Type: "ct", Length: int64(payloadSize)}, key); err != nil {
		t.Fatalf("failed to put it to cache: %s", err)
	}

	//simulate a value almost expired
	redis.SetTTL(key.String(), 2*time.Second)
	nbFileCacheBeforeGet, err := countFilesWithPrefix(os.TempDir(), redisTmpFilePrefix)
	if err != nil {
		t.Fatalf("could not read directory %s", err)
	}

	cachedData, err := cache.Get(key)
	if err != nil {
		t.Fatalf("expected cached to have the value")
	}
	nbFileCacheAfterGet, err := countFilesWithPrefix(os.TempDir(), redisTmpFilePrefix)
	if err != nil {
		t.Fatalf("could not read directory %s", err)
	}
	if nbFileCacheBeforeGet+1 != nbFileCacheAfterGet {
		t.Fatalf("expected a file to be stored by redisFileCache ")
	}

	cachedValue, err := io.ReadAll(cachedData.Data)
	if err != nil {
		t.Fatalf("could not read data from redisFileCache, err=%s", err)
	}
	if string(cachedValue) != expectedValue {
		t.Fatalf("got a value different than the expected one len(value)=%d vs len(expectedValue)=%d", len(string(cachedValue)), len(expectedValue))
	}
	cachedData.Data.Close()
	nbFileCacheAfterClose, err := countFilesWithPrefix(os.TempDir(), redisTmpFilePrefix)
	if err != nil {
		t.Fatalf("could not read directory %s", err)
	}

	if nbFileCacheBeforeGet != nbFileCacheAfterClose {
		t.Fatalf("expected the file stored by redisFileCache to be removed: nbFileCacheBeforeGet=%d | nbFileCacheAfterClose=%d", nbFileCacheBeforeGet, nbFileCacheAfterClose)
	}
}

func countFilesWithPrefix(dir, prefix string) (int, error) {
	count := 0