Add integration tests and service management for SteamCache

- Introduced integration tests for SteamCache to validate caching behavior with real Steam URLs.
- Implemented a ServiceManager to manage service configurations, allowing for dynamic detection of services based on User-Agent.
- Updated cache key generation to include service prefixes, enhancing cache organization and retrieval.
- Enhanced the caching logic to support multiple services, starting with Steam and Epic Games.
- Improved .gitignore to exclude test cache files while retaining necessary structure.

steamcache/steamcache_test.go

@@ -111,7 +111,8 @@ func TestCacheMissAndHit(t *testing.T) {
 }
 
 func TestURLHashing(t *testing.T) {
-	// Test the new SHA256-based cache key generation
+	// Test the SHA256-based cache key generation for Steam client requests
+	// The "steam/" prefix indicates the request came from a Steam client (User-Agent based)
 
 	testCases := []struct {
 		input       string
@@ -129,40 +130,188 @@ func TestURLHashing(t *testing.T) {
 			shouldCache: true,
 		},
 		{
-			input:       "/depot/invalid/path",
-			desc:        "invalid depot URL format",
-			shouldCache: true, // Still gets hashed, just not a proper Steam format
+			input:       "/appinfo/123456",
+			desc:        "app info URL",
+			shouldCache: true,
 		},
 		{
 			input:       "/some/other/path",
-			desc:        "non-Steam URL",
-			shouldCache: false, // Not cached
+			desc:        "any URL from Steam client",
+			shouldCache: true, // All URLs from Steam clients (detected via User-Agent) are cached
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.desc, func(t *testing.T) {
-			result := generateSteamCacheKey(tc.input)
+			result := generateServiceCacheKey(tc.input, "steam")
 
 			if tc.shouldCache {
 				// Should return a cache key with "steam/" prefix
 				if !strings.HasPrefix(result, "steam/") {
-					t.Errorf("generateSteamCacheKey(%s) = %s, expected steam/ prefix", tc.input, result)
+					t.Errorf("generateServiceCacheKey(%s, \"steam\") = %s, expected steam/ prefix", tc.input, result)
 				}
 				// Should be exactly 70 characters (6 for "steam/" + 64 for SHA256 hex)
 				if len(result) != 70 {
-					t.Errorf("generateSteamCacheKey(%s) length = %d, expected 70", tc.input, len(result))
+					t.Errorf("generateServiceCacheKey(%s, \"steam\") length = %d, expected 70", tc.input, len(result))
 				}
 			} else {
 				// Should return empty string for non-Steam URLs
 				if result != "" {
-					t.Errorf("generateSteamCacheKey(%s) = %s, expected empty string", tc.input, result)
+					t.Errorf("generateServiceCacheKey(%s, \"steam\") = %s, expected empty string", tc.input, result)
 				}
 			}
 		})
 	}
 }
 
+func TestServiceDetection(t *testing.T) {
+	// Create a service manager for testing
+	sm := NewServiceManager()
+
+	testCases := []struct {
+		userAgent     string
+		expectedName  string
+		expectedFound bool
+		desc          string
+	}{
+		{
+			userAgent:     "Valve/Steam HTTP Client 1.0",
+			expectedName:  "steam",
+			expectedFound: true,
+			desc:          "Valve Steam HTTP Client",
+		},
+		{
+			userAgent:     "Steam",
+			expectedName:  "steam",
+			expectedFound: true,
+			desc:          "Simple Steam user agent",
+		},
+		{
+			userAgent:     "SteamClient/1.0",
+			expectedName:  "steam",
+			expectedFound: true,
+			desc:          "SteamClient with version",
+		},
+		{
+			userAgent:     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+			expectedName:  "",
+			expectedFound: false,
+			desc:          "Browser user agent",
+		},
+		{
+			userAgent:     "",
+			expectedName:  "",
+			expectedFound: false,
+			desc:          "Empty user agent",
+		},
+		{
+			userAgent:     "curl/7.68.0",
+			expectedName:  "",
+			expectedFound: false,
+			desc:          "curl user agent",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			service, found := sm.DetectService(tc.userAgent)
+
+			if found != tc.expectedFound {
+				t.Errorf("DetectService(%s) found = %v, expected %v", tc.userAgent, found, tc.expectedFound)
+			}
+
+			if found && service.Name != tc.expectedName {
+				t.Errorf("DetectService(%s) service name = %s, expected %s", tc.userAgent, service.Name, tc.expectedName)
+			}
+		})
+	}
+}
+
+func TestServiceManagerExpandability(t *testing.T) {
+	// Create a service manager for testing
+	sm := NewServiceManager()
+
+	// Test adding a new service (Epic Games)
+	epicConfig := &ServiceConfig{
+		Name:   "epic",
+		Prefix: "epic",
+		UserAgents: []string{
+			`EpicGamesLauncher`,
+			`EpicGames`,
+			`Epic.*Launcher`,
+		},
+	}
+
+	err := sm.AddService(epicConfig)
+	if err != nil {
+		t.Fatalf("Failed to add Epic service: %v", err)
+	}
+
+	// Test Epic Games detection
+	epicTestCases := []struct {
+		userAgent     string
+		expectedName  string
+		expectedFound bool
+		desc          string
+	}{
+		{
+			userAgent:     "EpicGamesLauncher/1.0",
+			expectedName:  "epic",
+			expectedFound: true,
+			desc:          "Epic Games Launcher",
+		},
+		{
+			userAgent:     "EpicGames/2.0",
+			expectedName:  "epic",
+			expectedFound: true,
+			desc:          "Epic Games client",
+		},
+		{
+			userAgent:     "Epic Launcher 1.5",
+			expectedName:  "epic",
+			expectedFound: true,
+			desc:          "Epic Launcher with regex match",
+		},
+		{
+			userAgent:     "Steam",
+			expectedName:  "steam",
+			expectedFound: true,
+			desc:          "Steam should still work",
+		},
+		{
+			userAgent:     "Mozilla/5.0",
+			expectedName:  "",
+			expectedFound: false,
+			desc:          "Browser should not match any service",
+		},
+	}
+
+	for _, tc := range epicTestCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			service, found := sm.DetectService(tc.userAgent)
+
+			if found != tc.expectedFound {
+				t.Errorf("DetectService(%s) found = %v, expected %v", tc.userAgent, found, tc.expectedFound)
+			}
+
+			if found && service.Name != tc.expectedName {
+				t.Errorf("DetectService(%s) service name = %s, expected %s", tc.userAgent, service.Name, tc.expectedName)
+			}
+		})
+	}
+
+	// Test cache key generation for different services
+	steamKey := generateServiceCacheKey("/depot/123/chunk/abc", "steam")
+	epicKey := generateServiceCacheKey("/epic/123/chunk/abc", "epic")
+
+	if !strings.HasPrefix(steamKey, "steam/") {
+		t.Errorf("Steam cache key should start with 'steam/', got: %s", steamKey)
+	}
+	if !strings.HasPrefix(epicKey, "epic/") {
+		t.Errorf("Epic cache key should start with 'epic/', got: %s", epicKey)
+	}
+}
+
 // Removed hash calculation tests since we switched to lightweight validation
 
 func TestSteamKeySharding(t *testing.T) {