steamcache2/vfs/cache/cache_test.go

package cache

import (
	"errors"
	"testing"

	"s1d3sw1ped/SteamCache2/vfs"
	"s1d3sw1ped/SteamCache2/vfs/cachestate"
	"s1d3sw1ped/SteamCache2/vfs/memory"
	"s1d3sw1ped/SteamCache2/vfs/vfserror"
)

func testMemory() vfs.VFS {
	return memory.New(1024)
}

func TestNew(t *testing.T) {
	t.Parallel()

	fast := testMemory()
	slow := testMemory()

	cache := New(fast, slow, nil)
	if cache == nil {
		t.Fatal("expected cache to be non-nil")
	}
}

func TestNewPanics(t *testing.T) {
	t.Parallel()

	defer func() {
		if r := recover(); r == nil {
			t.Fatal("expected panic but did not get one")
		}
	}()

	New(nil, nil, nil)
}

func TestSetAndGet(t *testing.T) {
	t.Parallel()

	fast := testMemory()
	slow := testMemory()
	cache := New(fast, slow, nil)

	key := "test"
	value := []byte("value")

	if err := cache.Set(key, value); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	got, err := cache.Get(key)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if string(got) != string(value) {
		t.Fatalf("expected %s, got %s", value, got)
	}
}

func TestSetAndGetNoFast(t *testing.T) {
	t.Parallel()

	slow := testMemory()
	cache := New(nil, slow, nil)

	key := "test"
	value := []byte("value")

	if err := cache.Set(key, value); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	got, err := cache.Get(key)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if string(got) != string(value) {
		t.Fatalf("expected %s, got %s", value, got)
	}
}
func TestCaching(t *testing.T) {
	t.Parallel()

	fast := testMemory()
	slow := testMemory()
	cache := New(fast, slow, func(fi *vfs.FileInfo, cs cachestate.CacheState) bool {
		return true
	})

	key := "test"
	value := []byte("value")

	if err := fast.Set(key, value); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if err := slow.Set(key, value); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	_, state, err := cache.GetS(key)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if state != cachestate.CacheStateHit {
		t.Fatalf("expected %v, got %v", cachestate.CacheStateHit, state)
	}

	err = fast.Delete(key)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	got, state, err := cache.GetS(key)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if state != cachestate.CacheStateMiss {
		t.Fatalf("expected %v, got %v", cachestate.CacheStateMiss, state)
	}

	if string(got) != string(value) {
		t.Fatalf("expected %s, got %s", value, got)
	}

	err = cache.Delete(key)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	_, state, err = cache.GetS(key)
	if !errors.Is(err, vfserror.ErrNotFound) {
		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
	}
	if state != cachestate.CacheStateNotFound {
		t.Fatalf("expected %v, got %v", cachestate.CacheStateNotFound, state)
	}
}

func TestGetNotFound(t *testing.T) {
	t.Parallel()

	fast := testMemory()
	slow := testMemory()
	cache := New(fast, slow, nil)

	_, err := cache.Get("nonexistent")
	if !errors.Is(err, vfserror.ErrNotFound) {
		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
	}
}

func TestDelete(t *testing.T) {
	t.Parallel()

	fast := testMemory()
	slow := testMemory()
	cache := New(fast, slow, nil)

	key := "test"
	value := []byte("value")

	if err := cache.Set(key, value); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if err := cache.Delete(key); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	_, err := cache.Get(key)
	if !errors.Is(err, vfserror.ErrNotFound) {
		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
	}
}

func TestStat(t *testing.T) {
	t.Parallel()

	fast := testMemory()
	slow := testMemory()
	cache := New(fast, slow, nil)

	key := "test"
	value := []byte("value")

	if err := cache.Set(key, value); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	info, err := cache.Stat(key)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if info == nil {
		t.Fatal("expected file info to be non-nil")
	}
}