driver_memory_test.go

package cache

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

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

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

	t.Run("NewMemoryCache creates cache with memory driver", func(t *testing.T) {
		cache := NewMemoryCache[string](WithMemoryDefaultTTL(10 * time.Millisecond))
		require.NotNil(t, cache, "NewMemoryCache should return non-nil cache")

		// Verify it works
		err := cache.Set(ctx, "test", "value", DefaultTTL)
		require.NoError(t, err, "Set should work")

		val, found, err := cache.Get(ctx, "test")
		require.NoError(t, err, "Get should not return error")
		assert.True(t, found, "Get should find the value")
		assert.Equal(t, "value", val, "Get should return correct value")
	})

	t.Run("NewMemoryCache with options", func(t *testing.T) {
		cache := NewMemoryCache[string](WithMemoryDefaultTTL(50 * time.Millisecond))
		require.NotNil(t, cache, "NewMemoryCache should return non-nil cache")

		// Set with default TTL and verify expiration
		err := cache.Set(ctx, "expires", "value", DefaultTTL)
		require.NoError(t, err, "Set should work")

		time.Sleep(60 * time.Millisecond)

		_, found, err := cache.Get(ctx, "expires")
		require.NoError(t, err, "Get should not return error")
		assert.False(t, found, "Value should expire after default TTL")
	})
}

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

	// Create cache with 1 second default TTL
	c := NewMemoryCache[string](WithMemoryDefaultTTL(10 * time.Millisecond))

	// Test Set/Get with default TTL
	t.Run("Set and Get with default TTL", func(t *testing.T) {
		err := c.Set(ctx, "key1", "value1", DefaultTTL)
		require.NoError(t, err, "Set failed")

		val, found, err := c.Get(ctx, "key1")
		require.NoError(t, err, "Get should not return error")
		require.True(t, found, "Get should find the key")
		assert.Equal(t, "value1", val, "Get should return correct value")

		// Wait for expiration
		time.Sleep(20 * time.Millisecond)

		_, found, err = c.Get(ctx, "key1")
		require.NoError(t, err, "Get should not return error")
		assert.False(t, found, "Expected key to be expired")
	})

	// Test Set with custom TTL
	t.Run("Set with custom TTL", func(t *testing.T) {
		err := c.Set(ctx, "key2", "value2", WithTTL(20*time.Millisecond))
		require.NoError(t, err, "Set failed")

		// Should still exist after 10 milliseconds
		time.Sleep(10 * time.Millisecond)

		val, found, err := c.Get(ctx, "key2")
		require.NoError(t, err, "Get should not return error")
		require.True(t, found, "Get should find the key after 10ms")
		assert.Equal(t, "value2", val, "Get should return correct value")

		// Should expire after 30 milliseconds
		time.Sleep(30 * time.Millisecond)

		_, found, err = c.Get(ctx, "key2")
		require.NoError(t, err, "Get should not return error")
		assert.False(t, found, "Expected key to be expired")
	})

	// Test Set with Forever
	t.Run("Set with Forever", func(t *testing.T) {
		err := c.Set(ctx, "key3", "value3", Forever)
		require.NoError(t, err, "Set failed")

		// Should never expire
		time.Sleep(20 * time.Millisecond)

		val, found, err := c.Get(ctx, "key3")
		require.NoError(t, err, "Get should not return error")
		require.True(t, found, "Get should find the key")
		assert.Equal(t, "value3", val, "Get should return correct value")
	})

	// Test Remember
	t.Run("Remember", func(t *testing.T) {
		fetchCount := 0
		fetch := func(_ context.Context) (string, error) {
			fetchCount++
			return "computed", nil
		}

		// First call should fetch
		val, err := c.Remember(ctx, "key4", WithTTL(10*time.Millisecond), fetch)
		require.NoError(t, err, "Remember should not fail")
		assert.Equal(t, "computed", val, "Remember should return correct value")
		assert.Equal(t, 1, fetchCount, "Fetch should be called once")

		// Second call should use cache
		val, err = c.Remember(ctx, "key4", WithTTL(10*time.Millisecond), fetch)
		require.NoError(t, err, "Remember should not fail")
		assert.Equal(t, "computed", val, "Remember should return correct value")
		assert.Equal(t, 1, fetchCount, "Fetch should not be called again (cached)")

		time.Sleep(20 * time.Millisecond)

		// After expiration, Remember should call fetch again and increase fetchCount
		val, err = c.Remember(ctx, "key4", WithTTL(10*time.Millisecond), fetch)
		require.NoError(t, err, "Remember should not fail after expiration")
		assert.Equal(t, "computed", val, "Remember should return correct value")
		assert.Equal(t, 2, fetchCount, "Fetch should be called again after expiration")
	})

	// Test Has
	t.Run("Has", func(t *testing.T) {
		err := c.Set(ctx, "exists", "yes", DefaultTTL)
		require.NoError(t, err, "Set must not fail")

		has, err := c.Has(ctx, "exists")
		require.NoError(t, err, "Has should not return error")
		assert.True(t, has, "Has should return true for existing key")
		has, err = c.Has(ctx, "not-exists")
		require.NoError(t, err, "Has should not return error")
		assert.False(t, has, "Has should return false for non-existing key")
	})

	// Test Delete
	t.Run("Delete", func(t *testing.T) {
		err := c.Set(ctx, "to-delete", "value", DefaultTTL)
		require.NoError(t, err, "Set must not fail")

		has, err := c.Has(ctx, "to-delete")
		require.NoError(t, err, "Has should not return error")
		require.True(t, has, "Key should be set")

		err = c.Delete(ctx, "to-delete")
		require.NoError(t, err, "Delete should not fail")

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

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

	// Create a memory cache
	c := NewMemoryCache[string](WithMemoryDefaultTTL(10 * time.Millisecond))

	// Test Remember with a fetch function that returns a value
	fetch := func(_ context.Context) (string, error) {
		return "test-value", nil
	}

	// This should work normally since memory cache Set operations don't fail
	value, err := c.Remember(ctx, "test-key", DefaultTTL, fetch)
	require.NoError(t, err, "Remember should not fail for memory cache")
	assert.Equal(t, "test-value", value, "Remember should return correct value")

	// Test that the value is cached
	value, err = c.Remember(ctx, "test-key", DefaultTTL, func(_ context.Context) (string, error) {
		t.Fatal("Fetch function should not be called when value is cached")
		return "", nil
	})
	require.NoError(t, err, "Remember should not fail for cached value")
	assert.Equal(t, "test-value", value, "Remember should return cached value")

	// Test with a fetch function that returns an error
	_, err = c.Remember(ctx, "error-key", DefaultTTL, func(_ context.Context) (string, error) {
		return "", errors.New("fetch error")
	})
	require.Error(t, err, "Remember should fail when fetch function returns error")
	assert.Contains(t, err.Error(), "fetch value", "Error should contain 'fetch value'")
}