config/cache_test.go

package config

import (
	"testing"
	"time"

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

func TestDefaultCacheConfig(t *testing.T) {
	config := DefaultCacheConfig()

	assert.True(t, config.Enabled)
	assert.Equal(t, "5m", config.DefaultTTL)
	assert.Equal(t, "2m", config.SearchTTL)
	assert.Equal(t, "15m", config.MetadataTTL)
	assert.Equal(t, 1000, config.MaxSize)
}

func TestCacheConfigValidate(t *testing.T) {
	tests := []struct {
		name      string
		config    CacheConfig
		wantError bool
		errorMsg  string
	}{
		{
			name:      "disabled cache",
			config:    CacheConfig{Enabled: false},
			wantError: false,
		},
		{
			name: "valid cache config",
			config: CacheConfig{
				Enabled:     true,
				DefaultTTL:  "5m",
				SearchTTL:   "2m",
				MetadataTTL: "15m",
				MaxSize:     1000,
			},
			wantError: false,
		},
		{
			name: "invalid max size",
			config: CacheConfig{
				Enabled:     true,
				DefaultTTL:  "5m",
				SearchTTL:   "2m",
				MetadataTTL: "15m",
				MaxSize:     0,
			},
			wantError: true,
			errorMsg:  "cache max_size must be positive",
		},
		{
			name: "invalid default TTL",
			config: CacheConfig{
				Enabled:     true,
				DefaultTTL:  "invalid",
				SearchTTL:   "2m",
				MetadataTTL: "15m",
				MaxSize:     1000,
			},
			wantError: true,
			errorMsg:  "invalid default_ttl",
		},
		{
			name: "invalid search TTL",
			config: CacheConfig{
				Enabled:     true,
				DefaultTTL:  "5m",
				SearchTTL:   "bad-duration",
				MetadataTTL: "15m",
				MaxSize:     1000,
			},
			wantError: true,
			errorMsg:  "invalid search_ttl",
		},
		{
			name: "invalid metadata TTL",
			config: CacheConfig{
				Enabled:     true,
				DefaultTTL:  "5m",
				SearchTTL:   "2m",
				MetadataTTL: "not-a-duration",
				MaxSize:     1000,
			},
			wantError: true,
			errorMsg:  "invalid metadata_ttl",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := tt.config.Validate()

			if tt.wantError {
				assert.Error(t, err)
				assert.Contains(t, err.Error(), tt.errorMsg)
			} else {
				assert.NoError(t, err)
			}
		})
	}
}

func TestCacheConfigGetTTLMethods(t *testing.T) {
	config := &CacheConfig{
		Enabled:     true,
		DefaultTTL:  "5m",
		SearchTTL:   "2m",
		MetadataTTL: "15m",
		MaxSize:     1000,
	}

	// Test valid TTL parsing
	assert.Equal(t, 5*time.Minute, config.GetDefaultTTL())
	assert.Equal(t, 2*time.Minute, config.GetSearchTTL())
	assert.Equal(t, 15*time.Minute, config.GetMetadataTTL())

	// Test disabled cache returns 0
	disabledConfig := &CacheConfig{Enabled: false}
	assert.Equal(t, time.Duration(0), disabledConfig.GetDefaultTTL())
	assert.Equal(t, time.Duration(0), disabledConfig.GetSearchTTL())
	assert.Equal(t, time.Duration(0), disabledConfig.GetMetadataTTL())

	// Test invalid TTL falls back to defaults
	invalidConfig := &CacheConfig{
		Enabled:     true,
		DefaultTTL:  "invalid",
		SearchTTL:   "bad",
		MetadataTTL: "worse",
	}
	assert.Equal(t, 5*time.Minute, invalidConfig.GetDefaultTTL())
	assert.Equal(t, 2*time.Minute, invalidConfig.GetSearchTTL())
	assert.Equal(t, 15*time.Minute, invalidConfig.GetMetadataTTL())
}

func TestCacheConfigVariousTTLFormats(t *testing.T) {
	tests := []struct {
		name     string
		ttl      string
		expected time.Duration
	}{
		{
			name:     "seconds",
			ttl:      "30s",
			expected: 30 * time.Second,
		},
		{
			name:     "minutes",
			ttl:      "5m",
			expected: 5 * time.Minute,
		},
		{
			name:     "hours",
			ttl:      "1h",
			expected: 1 * time.Hour,
		},
		{
			name:     "mixed format",
			ttl:      "1h30m",
			expected: 1*time.Hour + 30*time.Minute,
		},
		{
			name:     "microseconds",
			ttl:      "500ms",
			expected: 500 * time.Millisecond,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			config := &CacheConfig{
				Enabled:    true,
				DefaultTTL: tt.ttl,
			}

			assert.Equal(t, tt.expected, config.GetDefaultTTL())
		})
	}
}