cache_test.go

package cache

import (
	"context"
	"errors"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// mockDriver is a mock implementation of Driver for testing
type mockDriver[Value any] struct {
	storage map[Key]Value
	getErr  error
	setErr  error
	hasErr  error
	delErr  error
}

func newMockDriver[Value any]() *mockDriver[Value] {
	return &mockDriver[Value]{
		storage: make(map[Key]Value),
	}
}

func (m *mockDriver[Value]) Get(_ context.Context, key Key) (Value, bool, error) { //nolint:ireturn
	if m.getErr != nil {
		var zero Value
		return zero, false, m.getErr
	}
	val, ok := m.storage[key]
	return val, ok, nil
}

func (m *mockDriver[Value]) Set(_ context.Context, key Key, value Value, _ TTL) error {
	if m.setErr != nil {
		return m.setErr
	}
	m.storage[key] = value
	return nil
}

func (m *mockDriver[Value]) Has(_ context.Context, key Key) (bool, error) {
	if m.hasErr != nil {
		return false, m.hasErr
	}
	_, ok := m.storage[key]
	return ok, nil
}

func (m *mockDriver[Value]) Delete(_ context.Context, key Key) error {
	if m.delErr != nil {
		return m.delErr
	}
	delete(m.storage, key)
	return nil
}

func TestNewCache(t *testing.T) {
	driver := newMockDriver[string]()
	cache := NewCache(driver)

	require.NotNil(t, cache, "NewCache should return non-nil cache")
	assert.Equal(t, driver, cache.Driver(), "Cache should return the same driver")
}

func TestCache_Get(t *testing.T) {
	ctx := t.Context()
	driver := newMockDriver[string]()
	cache := NewCache(driver)

	// Test Get with non-existing key
	val, found, err := cache.Get(ctx, "non-existing")
	require.NoError(t, err, "Get should not return error for non-existing key")
	assert.False(t, found, "Get should return false for non-existing key")
	assert.Empty(t, val, "Get should return zero value for non-existing key")

	// Test Get with existing key
	driver.storage["existing"] = "value"
	val, found, err = cache.Get(ctx, "existing")
	require.NoError(t, err, "Get should not return error for existing key")
	assert.True(t, found, "Get should return true for existing key")
	assert.Equal(t, "value", val, "Get should return correct value")
}

func TestCache_Set(t *testing.T) {
	ctx := t.Context()
	driver := newMockDriver[string]()
	cache := NewCache(driver)

	// Test Set with default TTL
	err := cache.Set(ctx, "key1", "value1", DefaultTTL)
	require.NoError(t, err, "Set should not fail")
	assert.Equal(t, "value1", driver.storage["key1"], "Set should store value in driver")

	// Test Set with custom TTL
	err = cache.Set(ctx, "key2", "value2", WithTTL(5*time.Minute))
	require.NoError(t, err, "Set should not fail with custom TTL")
	assert.Equal(t, "value2", driver.storage["key2"], "Set should store value with custom TTL")

	// Test Set with Forever
	err = cache.Set(ctx, "key3", "value3", Forever)
	require.NoError(t, err, "Set should not fail with Forever")
	assert.Equal(t, "value3", driver.storage["key3"], "Set should store value with Forever")

	// Test Set error handling
	driver.setErr = errors.New("set error")
	err = cache.Set(ctx, "key4", "value4", DefaultTTL)
	require.Error(t, err, "Set should return error when driver.Set fails")
	assert.Equal(t, "set error", err.Error(), "Set should return driver error")
}

func TestCache_Has(t *testing.T) {
	ctx := t.Context()
	driver := newMockDriver[string]()
	cache := NewCache(driver)

	// Test Has with non-existing key
	has, err := cache.Has(ctx, "non-existing")
	require.NoError(t, err, "Has should not return error for non-existing key")
	assert.False(t, has, "Has should return false for non-existing key")

	// Test Has with existing key
	driver.storage["existing"] = "value"
	has, err = cache.Has(ctx, "existing")
	require.NoError(t, err, "Has should not return error for existing key")
	assert.True(t, has, "Has should return true for existing key")
}

func TestCache_Delete(t *testing.T) {
	ctx := t.Context()
	driver := newMockDriver[string]()
	cache := NewCache(driver)

	// Test Delete with existing key
	driver.storage["to-delete"] = "value"
	has, err := driver.Has(ctx, "to-delete")
	require.NoError(t, err, "Has should not return error")
	require.True(t, has, "Key should exist before delete")

	err = cache.Delete(ctx, "to-delete")
	require.NoError(t, err, "Delete should not fail")
	has, err = driver.Has(ctx, "to-delete")
	require.NoError(t, err, "Has should not return error")
	assert.False(t, has, "Key should not exist after delete")

	// Test Delete with non-existing key (should not error)
	err = cache.Delete(ctx, "non-existing")
	require.NoError(t, err, "Delete should not fail for non-existing key")

	// Test Delete error handling
	driver.delErr = errors.New("delete error")
	err = cache.Delete(ctx, "key")
	require.Error(t, err, "Delete should return error when driver.Delete fails")
	assert.Equal(t, "delete error", err.Error(), "Delete should return driver error")
}

func TestCache_Remember(t *testing.T) {
	ctx := t.Context()

	t.Run("Cache hit - returns cached value", func(t *testing.T) {
		driver := newMockDriver[string]()
		cache := NewCache(driver)

		// Pre-populate cache
		driver.storage["cached"] = "cached-value"

		fetchCount := 0
		fetch := func(_ context.Context) (string, error) {
			fetchCount++
			return "fetched-value", nil
		}

		val, err := cache.Remember(ctx, "cached", DefaultTTL, fetch)
		require.NoError(t, err, "Remember should not fail")
		assert.Equal(t, "cached-value", val, "Remember should return cached value")
		assert.Equal(t, 0, fetchCount, "Fetch should not be called when cache hit")
	})

	t.Run("Cache miss - fetches and stores value", func(t *testing.T) {
		driver := newMockDriver[string]()
		cache := NewCache(driver)

		fetchCount := 0
		fetch := func(_ context.Context) (string, error) {
			fetchCount++
			return "fetched-value", nil
		}

		val, err := cache.Remember(ctx, "miss", DefaultTTL, fetch)
		require.NoError(t, err, "Remember should not fail")
		assert.Equal(t, "fetched-value", val, "Remember should return fetched value")
		assert.Equal(t, 1, fetchCount, "Fetch should be called once")

		// Verify value was stored in cache
		cachedVal, found, err := driver.Get(ctx, "miss")
		require.NoError(t, err, "Get should not return error")
		assert.True(t, found, "Value should be stored in cache")
		assert.Equal(t, "fetched-value", cachedVal, "Cached value should match")
	})

	t.Run("Fetch error - returns error without caching", func(t *testing.T) {
		driver := newMockDriver[string]()
		cache := NewCache(driver)

		fetchErr := errors.New("fetch failed")
		fetch := func(_ context.Context) (string, error) {
			return "", fetchErr
		}

		val, err := cache.Remember(ctx, "error-key", DefaultTTL, fetch)
		require.Error(t, err, "Remember should return error when fetch fails")
		assert.Contains(t, err.Error(), "fetch value", "Error should contain 'fetch value'")
		assert.Contains(t, err.Error(), "fetch failed", "Error should wrap fetch error")
		assert.Empty(t, val, "Remember should return zero value on error")

		// Verify nothing was stored in cache
		_, found, err := driver.Get(ctx, "error-key")
		require.NoError(t, err, "Get should not return error")
		assert.False(t, found, "Value should not be stored when fetch fails")
	})

	t.Run("Set error after fetch - returns value but wraps error", func(t *testing.T) {
		driver := newMockDriver[string]()
		driver.setErr = errors.New("cache set failed")
		cache := NewCache(driver)

		fetch := func(_ context.Context) (string, error) {
			return "fetched-value", nil
		}

		val, err := cache.Remember(ctx, "set-error", DefaultTTL, fetch)
		require.Error(t, err, "Remember should return error when Set fails")
		require.ErrorIs(t, err, ErrCacheSetFailed, "Error should wrap ErrCacheSetFailed")
		assert.Equal(t, "fetched-value", val, "Remember should return fetched value even if Set fails")
		assert.Contains(t, err.Error(), "cache set failed", "Error should contain Set error")
	})

	t.Run("Remember with different TTL values", func(t *testing.T) {
		driver := newMockDriver[string]()
		cache := NewCache(driver)

		fetch := func(_ context.Context) (string, error) {
			return "value", nil
		}

		// Test with DefaultTTL
		_, err := cache.Remember(ctx, "default-ttl", DefaultTTL, fetch)
		require.NoError(t, err, "Remember should work with DefaultTTL")

		// Test with custom TTL
		_, err = cache.Remember(ctx, "custom-ttl", WithTTL(5*time.Minute), fetch)
		require.NoError(t, err, "Remember should work with custom TTL")

		// Test with Forever
		_, err = cache.Remember(ctx, "forever-ttl", Forever, fetch)
		require.NoError(t, err, "Remember should work with Forever")
	})

	t.Run("Remember with complex type", func(t *testing.T) {
		type User struct {
			ID   int
			Name string
		}

		driver := newMockDriver[User]()
		cache := NewCache(driver)

		fetchCount := 0
		expectedUser := User{ID: 123, Name: "John"}
		fetch := func(_ context.Context) (User, error) {
			fetchCount++
			return expectedUser, nil
		}

		// First call - cache miss
		user, err := cache.Remember(ctx, "user:123", DefaultTTL, fetch)
		require.NoError(t, err, "Remember should not fail")
		assert.Equal(t, expectedUser, user, "Remember should return correct user")
		assert.Equal(t, 1, fetchCount, "Fetch should be called once")

		// Second call - cache hit
		user, err = cache.Remember(ctx, "user:123", DefaultTTL, fetch)
		require.NoError(t, err, "Remember should not fail")
		assert.Equal(t, expectedUser, user, "Remember should return cached user")
		assert.Equal(t, 1, fetchCount, "Fetch should not be called again")
	})
}

func TestCache_Driver(t *testing.T) {
	driver := newMockDriver[string]()
	cache := NewCache(driver)

	returnedDriver := cache.Driver()
	assert.Equal(t, driver, returnedDriver, "Driver should return the same driver instance")
}

func TestTTL(t *testing.T) {
	t.Run("DefaultTTL", func(t *testing.T) {
		assert.True(t, DefaultTTL.useDefault, "DefaultTTL should have useDefault=true")
	})

	t.Run("Forever", func(t *testing.T) {
		assert.False(t, Forever.useDefault, "Forever should have useDefault=false")
		assert.Equal(t, time.Duration(0), Forever.duration, "Forever should have duration=0")
	})

	t.Run("WithTTL", func(t *testing.T) {
		ttl := WithTTL(5 * time.Minute)
		assert.False(t, ttl.useDefault, "WithTTL should have useDefault=false")
		assert.Equal(t, 5*time.Minute, ttl.duration, "WithTTL should set correct duration")
	})
}

func TestCache_InterfaceCompliance(t *testing.T) {
	// Test that cache implements Cacher interface
	var _ Cacher[string] = (*Cache[string])(nil)
	var _ Cacher[int] = (*Cache[int])(nil)

	type User struct {
		ID int
	}
	var _ Cacher[User] = (*Cache[User])(nil)
}