steamcache2/vfs/disk/disk_test.go

// vfs/disk/disk_test.go
package disk

import (
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"s1d3sw1ped/SteamCache2/vfs/vfserror"
	"testing"
)

func TestCreateAndOpen(t *testing.T) {
	m := NewSkipInit(t.TempDir(), 1024)
	key := "key"
	value := []byte("value")

	w, err := m.Create(key, int64(len(value)))
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}
	w.Write(value)
	w.Close()

	rc, err := m.Open(key)
	if err != nil {
		t.Fatalf("Open failed: %v", err)
	}
	got, _ := io.ReadAll(rc)
	rc.Close()

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

func TestOverwrite(t *testing.T) {
	m := NewSkipInit(t.TempDir(), 1024)
	key := "key"
	value1 := []byte("value1")
	value2 := []byte("value2")

	w, err := m.Create(key, int64(len(value1)))
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}
	w.Write(value1)
	w.Close()

	w, err = m.Create(key, int64(len(value2)))
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}
	w.Write(value2)
	w.Close()

	rc, err := m.Open(key)
	if err != nil {
		t.Fatalf("Open failed: %v", err)
	}
	got, _ := io.ReadAll(rc)
	rc.Close()

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

func TestDelete(t *testing.T) {
	m := NewSkipInit(t.TempDir(), 1024)
	key := "key"
	value := []byte("value")

	w, err := m.Create(key, int64(len(value)))
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}
	w.Write(value)
	w.Close()

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

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

func TestCapacityLimit(t *testing.T) {
	m := NewSkipInit(t.TempDir(), 10)
	for i := 0; i < 11; i++ {
		w, err := m.Create(fmt.Sprintf("key%d", i), 1)
		if err != nil && i < 10 {
			t.Errorf("Create failed: %v", err)
		} else if i == 10 && err == nil {
			t.Errorf("Create succeeded: got nil, want %v", vfserror.ErrDiskFull)
		}
		if i < 10 {
			w.Write([]byte("1"))
			w.Close()
		}
	}
}

func TestInitExistingFiles(t *testing.T) {
	td := t.TempDir()

	path := filepath.Join(td, "test", "key")
	os.MkdirAll(filepath.Dir(path), 0755)
	os.WriteFile(path, []byte("value"), 0644)

	m := New(td, 10)
	rc, err := m.Open("test/key")
	if err != nil {
		t.Fatalf("Open failed: %v", err)
	}
	got, _ := io.ReadAll(rc)
	rc.Close()

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

	s, err := m.Stat("test/key")
	if err != nil {
		t.Fatalf("Stat failed: %v", err)
	}
	if s == nil {
		t.Error("Stat returned nil")
	}
	if s != nil && s.Name() != "test/key" {
		t.Errorf("Stat failed: got %s, want %s", s.Name(), "test/key")
	}
}

func TestSizeConsistency(t *testing.T) {
	td := t.TempDir()
	os.WriteFile(filepath.Join(td, "key2"), []byte("value2"), 0644)

	m := New(td, 1024)
	if m.Size() != 6 {
		t.Errorf("Size failed: got %d, want 6", m.Size())
	}

	w, err := m.Create("key", 5)
	if err != nil {
		t.Errorf("Create failed: %v", err)
	}
	w.Write([]byte("value"))
	w.Close()

	w, err = m.Create("key1", 6)
	if err != nil {
		t.Errorf("Create failed: %v", err)
	}
	w.Write([]byte("value1"))
	w.Close()

	assumedSize := int64(6 + 5 + 6)
	if assumedSize != m.Size() {
		t.Errorf("Size failed: got %d, want %d", m.Size(), assumedSize)
	}

	rc, err := m.Open("key")
	if err != nil {
		t.Errorf("Open failed: %v", err)
	}
	d, _ := io.ReadAll(rc)
	rc.Close()
	if string(d) != "value" {
		t.Errorf("Get failed: got %s, want value", d)
	}

	m = New(td, 1024)
	if assumedSize != m.Size() {
		t.Errorf("Size failed: got %d, want %d", m.Size(), assumedSize)
	}
}