cache_test.go

package fastcache

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"sync"
	"testing"
)

func TestCache(t *testing.T) {
	c, err := NewCache(64*MB, &Config{
		MemoryType: GO,
	})
	if err != nil {
		panic(err)
	}

	var wg sync.WaitGroup
	n := 1024
	wg.Add(n)
	for i := 0; i < n; i++ {
		i := i
		go func() {
			defer wg.Done()
			key := []byte(fmt.Sprintf("key_%d", i))
			value := key
			err = c.Set(key, value)
			if err != nil {
				panic(err)
			}

			exists := c.Has(key)
			if !exists {
				panic("key must exists")
			}

			v, err := c.Get(key)
			if err != nil {
				panic(err)
			}

			if string(v) != string(key) {
				panic(fmt.Errorf("get key: %s value: %s not equals", key, v))
			}

			err = c.Delete(key)
			if err != nil {
				panic(err)
			}

			_, err = c.Get(key)
			if err == nil || !errors.Is(err, ErrNotFound) {
				panic("expect ErrNotFound")
			}
		}()
	}

	wg.Wait()
}

// TestMmapPersistence verifies that data written to an MMAP cache
// survives close/reopen cycles. This tests the Sync() functionality
// added to ensure durability.
func TestMmapPersistence(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "fastcache_test")
	if err != nil {
		t.Fatalf("failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	dbPath := filepath.Join(tmpDir, "test_mmap_db")

	// Create cache and write data
	cache1, err := NewCache(64*MB, &Config{
		MemoryType: MMAP,
		MemoryKey:  dbPath,
	})
	if err != nil {
		t.Fatalf("failed to create cache: %v", err)
	}

	// Write test data
	testData := map[string]string{
		"key1": "value1",
		"key2": "value2",
		"key3": "a longer value with more data",
	}

	for k, v := range testData {
		if err := cache1.Set([]byte(k), []byte(v)); err != nil {
			t.Fatalf("failed to set key %s: %v", k, err)
		}
	}

	// Close the cache - this should sync to disk
	if err := cache1.Close(); err != nil {
		t.Fatalf("failed to close cache: %v", err)
	}

	// Reopen the cache
	cache2, err := NewCache(64*MB, &Config{
		MemoryType: MMAP,
		MemoryKey:  dbPath,
	})
	if err != nil {
		t.Fatalf("failed to reopen cache: %v", err)
	}
	defer cache2.Close()

	// Verify all data survived
	for k, expectedV := range testData {
		gotV, err := cache2.Get([]byte(k))
		if err != nil {
			t.Errorf("failed to get key %s after reopen: %v", k, err)
			continue
		}
		if string(gotV) != expectedV {
			t.Errorf("key %s: got %q, want %q", k, string(gotV), expectedV)
		}
	}
}

// TestSyncExplicit verifies that Sync() can be called explicitly
// and data is persisted even without calling Close().
func TestSyncExplicit(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "fastcache_sync_test")
	if err != nil {
		t.Fatalf("failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	dbPath := filepath.Join(tmpDir, "test_sync_db")

	cache1, err := NewCache(64*MB, &Config{
		MemoryType: MMAP,
		MemoryKey:  dbPath,
	})
	if err != nil {
		t.Fatalf("failed to create cache: %v", err)
	}

	// Write and sync without close
	key := []byte("sync_test_key")
	value := []byte("sync_test_value")

	if err := cache1.Set(key, value); err != nil {
		t.Fatalf("failed to set: %v", err)
	}

	// Explicit sync
	if err := cache1.Sync(); err != nil {
		t.Fatalf("failed to sync: %v", err)
	}

	// Reopen without calling Close() on first cache (simulates crash)
	cache2, err := NewCache(64*MB, &Config{
		MemoryType: MMAP,
		MemoryKey:  dbPath,
	})
	if err != nil {
		t.Fatalf("failed to reopen cache: %v", err)
	}
	defer cache2.Close()

	// Verify data survived
	gotV, err := cache2.Get(key)
	if err != nil {
		t.Fatalf("failed to get key after sync+reopen: %v", err)
	}
	if string(gotV) != string(value) {
		t.Errorf("got %q, want %q", string(gotV), string(value))
	}
}