feat: add config validation to NewCacheBackend (#204)

Signed-off-by: cryo <[email protected]>

Author: cryo-zd

src/semantic-router/pkg/cache/cache_factory.go

@@ -9,6 +9,10 @@ import (
 
 // NewCacheBackend creates a cache backend instance from the provided configuration
 func NewCacheBackend(config CacheConfig) (CacheBackend, error) {
+	if err := ValidateCacheConfig(config); err != nil {
+		return nil, fmt.Errorf("invalid cache config: %w", err)
+	}
+
 	if !config.Enabled {
 		// Create a disabled cache backend
 		observability.Debugf("Cache disabled - creating disabled in-memory cache backend")
@@ -34,17 +38,6 @@ func NewCacheBackend(config CacheConfig) (CacheBackend, error) {
 	case MilvusCacheType:
 		observability.Debugf("Creating Milvus cache backend - ConfigPath: %s, TTL: %ds, Threshold: %.3f",
 			config.BackendConfigPath, config.TTLSeconds, config.SimilarityThreshold)
-		if config.BackendConfigPath == "" {
-			return nil, fmt.Errorf("backend_config_path is required for Milvus cache backend")
-		}
-
-		// Ensure the Milvus configuration file exists
-		if _, err := os.Stat(config.BackendConfigPath); os.IsNotExist(err) {
-			observability.Debugf("Milvus config file not found: %s", config.BackendConfigPath)
-			return nil, fmt.Errorf("Milvus config file not found: %s", config.BackendConfigPath)
-		}
-		observability.Debugf("Milvus config file found: %s", config.BackendConfigPath)
-
 		options := MilvusCacheOptions{
 			Enabled:             config.Enabled,
 			SimilarityThreshold: config.SimilarityThreshold,
@@ -75,19 +68,22 @@ func ValidateCacheConfig(config CacheConfig) error {
 		return fmt.Errorf("ttl_seconds cannot be negative, got: %d", config.TTLSeconds)
 	}
 
-	// Check max entries for in-memory cache
-	if config.BackendType == InMemoryCacheType || config.BackendType == "" {
+	// Check backend-specific requirements
+	switch config.BackendType {
+	case InMemoryCacheType, "":
 		if config.MaxEntries < 0 {
 			return fmt.Errorf("max_entries cannot be negative for in-memory cache, got: %d", config.MaxEntries)
 		}
-	}
-
-	// Check backend-specific requirements
-	switch config.BackendType {
 	case MilvusCacheType:
 		if config.BackendConfigPath == "" {
 			return fmt.Errorf("backend_config_path is required for Milvus cache backend")
 		}
+		// Ensure the Milvus configuration file exists
+		if _, err := os.Stat(config.BackendConfigPath); os.IsNotExist(err) {
+			observability.Debugf("Milvus config file not found: %s", config.BackendConfigPath)
+			return fmt.Errorf("milvus config file not found: %s", config.BackendConfigPath)
+		}
+		observability.Debugf("Milvus config file found: %s", config.BackendConfigPath)
 	}
 
 	return nil

src/semantic-router/pkg/cache/cache_test.go

@@ -133,36 +133,6 @@ development:
 					Expect(err).NotTo(HaveOccurred())
 				})
 
-				It("should return error when backend_config_path is missing", func() {
-					config := cache.CacheConfig{
-						BackendType:         cache.MilvusCacheType,
-						Enabled:             true,
-						SimilarityThreshold: 0.8,
-						TTLSeconds:          3600,
-						// BackendConfigPath is missing
-					}
-
-					backend, err := cache.NewCacheBackend(config)
-					Expect(err).To(HaveOccurred())
-					Expect(err.Error()).To(ContainSubstring("backend_config_path is required"))
-					Expect(backend).To(BeNil())
-				})
-
-				It("should return error when backend_config_path file doesn't exist", func() {
-					config := cache.CacheConfig{
-						BackendType:         cache.MilvusCacheType,
-						Enabled:             true,
-						SimilarityThreshold: 0.8,
-						TTLSeconds:          3600,
-						BackendConfigPath:   "/nonexistent/milvus.yaml",
-					}
-
-					backend, err := cache.NewCacheBackend(config)
-					Expect(err).To(HaveOccurred())
-					Expect(err.Error()).To(ContainSubstring("config file not found"))
-					Expect(backend).To(BeNil())
-				})
-
 				It("should create Milvus cache backend successfully with valid config", func() {
 					config := cache.CacheConfig{
 						BackendType:         cache.MilvusCacheType,
@@ -221,6 +191,25 @@ development:
 					Expect(backend).To(BeNil())
 				})
 			})
+
+			Context("with invalid config but valid backend type", func() {
+				It("should return error due to validation when config has invalid values", func() {
+					config := cache.CacheConfig{
+						BackendType:         cache.InMemoryCacheType, // valid backend type
+						Enabled:             true,
+						SimilarityThreshold: -0.8, // invalid
+						MaxEntries:          10,
+						TTLSeconds:          -1, // invalid
+					}
+
+					backend, err := cache.NewCacheBackend(config)
+
+					Expect(err).To(HaveOccurred())
+					Expect(err.Error()).To(ContainSubstring("invalid cache config")) // ensure from config validation
+					Expect(backend).To(BeNil())
+				})
+			})
+
 		})
 
 		Describe("ValidateCacheConfig", func() {
@@ -319,6 +308,20 @@ development:
 				Expect(err.Error()).To(ContainSubstring("backend_config_path is required for Milvus"))
 			})
 
+			It("should return error when Milvus backend_config_path file doesn't exist", func() {
+				config := cache.CacheConfig{
+					BackendType:         cache.MilvusCacheType,
+					Enabled:             true,
+					SimilarityThreshold: 0.8,
+					TTLSeconds:          3600,
+					BackendConfigPath:   "/nonexistent/milvus.yaml",
+				}
+
+				err := cache.ValidateCacheConfig(config)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("config file not found"))
+			})
+
 			It("should validate edge case values", func() {
 				config := cache.CacheConfig{
 					BackendType:         cache.InMemoryCacheType,