changes from review

Author: taskbot

pkg/cache/validating_cache.go

@@ -162,6 +162,12 @@ func (c *ValidatingCache[K, V]) Set(key K, value V) {
 	c.lruCache.Add(key, value)
 }
 
+// Delete removes the entry for key from the cache, invoking onEvict if the key
+// was present. It is a no-op if the key does not exist.
+func (c *ValidatingCache[K, V]) Delete(key K) {
+	c.lruCache.Remove(key)
+}
+
 // Len returns the number of entries currently in the cache.
 func (c *ValidatingCache[K, V]) Len() int {
 	return c.lruCache.Len()

test/e2e/thv-operator/virtualmcp/helpers.go

@@ -828,7 +828,7 @@ func GetVMCPNodePort(
 		}
 
 		// Verify the HTTP server is ready to handle requests
-		if err := checkHTTPHealthReady(nodePort, 2*time.Second); err != nil {
+		if err := checkHTTPHealthReady(nodePort); err != nil {
 			return fmt.Errorf("nodePort %d accessible but HTTP server not ready: %w", nodePort, err)
 		}
 
@@ -854,8 +854,8 @@ func checkPortAccessible(nodePort int32, timeout time.Duration) error {
 
 // checkHTTPHealthReady verifies the HTTP server is ready by checking the /health endpoint.
 // This is more reliable than just TCP check as it ensures the application is serving requests.
-func checkHTTPHealthReady(nodePort int32, timeout time.Duration) error {
-	httpClient := &http.Client{Timeout: timeout}
+func checkHTTPHealthReady(nodePort int32) error {
+	httpClient := &http.Client{Timeout: 2 * time.Second}
 	url := fmt.Sprintf("http://localhost:%d/health", nodePort)
 
 	resp, err := httpClient.Get(url)

test/e2e/thv-operator/virtualmcp/mcpserver_scaling_test.go

@@ -29,15 +29,17 @@ import (
 	"github.com/stacklok/toolhive/test/e2e/thv-operator/testutil"
 )
 
+const proxyPort = int32(8080)
+
 // deployRedis creates a single-replica Redis Deployment and ClusterIP Service.
 // Returns after the deployment has at least one ready replica.
-func deployRedis(namespace, name string, timeout, pollInterval time.Duration) {
+func deployRedis(name string) {
 	labels := map[string]string{"app": name}
 
 	deployment := &appsv1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
-			Namespace: namespace,
+			Namespace: defaultNamespace,
 			Labels:    labels,
 		},
 		Spec: appsv1.DeploymentSpec{
@@ -69,7 +71,7 @@ func deployRedis(namespace, name string, timeout, pollInterval time.Duration) {
 	service := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
-			Namespace: namespace,
+			Namespace: defaultNamespace,
 		},
 		Spec: corev1.ServiceSpec{
 			Selector: labels,
@@ -86,20 +88,20 @@ func deployRedis(namespace, name string, timeout, pollInterval time.Duration) {
 	ginkgo.By("Waiting for Redis to become ready")
 	gomega.Eventually(func() bool {
 		dep := &appsv1.Deployment{}
-		if err := k8sClient.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, dep); err != nil {
+		if err := k8sClient.Get(ctx, types.NamespacedName{Name: name, Namespace: defaultNamespace}, dep); err != nil {
 			return false
 		}
 		return dep.Status.ReadyReplicas > 0
-	}, timeout, pollInterval).Should(gomega.BeTrue(), "Redis should be ready")
+	}, e2eTimeout, e2ePollInterval).Should(gomega.BeTrue(), "Redis should be ready")
 }
 
 // cleanupRedis removes the Redis Deployment and Service.
-func cleanupRedis(namespace, name string) {
+func cleanupRedis(name string) {
 	_ = k8sClient.Delete(ctx, &appsv1.Deployment{
-		ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: namespace},
+		ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: defaultNamespace},
 	})
 	_ = k8sClient.Delete(ctx, &corev1.Service{
-		ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: namespace},
+		ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: defaultNamespace},
 	})
 }
 
@@ -160,9 +162,9 @@ func portForwardToPod(podName string) (int, func(), error) {
 	kubeconfigArg := fmt.Sprintf("--kubeconfig=%s", kubeconfig)
 	//nolint:gosec // kubeconfig, podName, and ports are test-controlled values
 	cmd := exec.Command("kubectl", kubeconfigArg,
-		"-n", "default", "port-forward",
+		"-n", defaultNamespace, "port-forward",
 		fmt.Sprintf("pod/%s", podName),
-		fmt.Sprintf("%d:%d", localPort, 8080))
+		fmt.Sprintf("%d:%d", localPort, proxyPort))
 	if err := cmd.Start(); err != nil {
 		return 0, nil, fmt.Errorf("failed to start port-forward to %s: %w", podName, err)
 	}
@@ -190,10 +192,8 @@ func portForwardToPod(podName string) (int, func(), error) {
 
 var _ = ginkgo.Describe("MCPServer Cross-Replica Session Routing with Redis", func() {
 	const (
-		timeout          = time.Minute * 5
-		pollInterval     = time.Second * 2
-		defaultNamespace = "default"
-		proxyPort        = int32(8080)
+		timeout      = time.Minute * 5
+		pollInterval = time.Second * 2
 	)
 
 	ginkgo.Context("When MCPServer has backendReplicas=2 and proxy runner restarts", ginkgo.Ordered, func() {
@@ -211,7 +211,7 @@ var _ = ginkgo.Describe("MCPServer Cross-Replica Session Routing with Redis", fu
 			nodePortName = mcpServerName + "-nodeport"
 
 			ginkgo.By("Deploying Redis for session storage")
-			deployRedis(defaultNamespace, redisName, timeout, pollInterval)
+			deployRedis(redisName)
 
 			replicas := int32(1)
 			backendReplicas := int32(2)
@@ -258,7 +258,7 @@ var _ = ginkgo.Describe("MCPServer Cross-Replica Session Routing with Redis", fu
 				if err := checkPortAccessible(nodePort, 1*time.Second); err != nil {
 					return fmt.Errorf("nodePort %d not accessible: %w", nodePort, err)
 				}
-				if err := checkHTTPHealthReady(nodePort, 2*time.Second); err != nil {
+				if err := checkHTTPHealthReady(nodePort); err != nil {
 					return fmt.Errorf("nodePort %d not ready: %w", nodePort, err)
 				}
 				return nil
@@ -272,7 +272,7 @@ var _ = ginkgo.Describe("MCPServer Cross-Replica Session Routing with Redis", fu
 			_ = k8sClient.Delete(ctx, &corev1.Service{
 				ObjectMeta: metav1.ObjectMeta{Name: nodePortName, Namespace: defaultNamespace},
 			})
-			cleanupRedis(defaultNamespace, redisName)
+			cleanupRedis(redisName)
 
 			gomega.Eventually(func() bool {
 				err := k8sClient.Get(ctx, types.NamespacedName{Name: mcpServerName, Namespace: defaultNamespace}, &mcpv1alpha1.MCPServer{})
@@ -328,7 +328,7 @@ var _ = ginkgo.Describe("MCPServer Cross-Replica Session Routing with Redis", fu
 
 			ginkgo.By("Waiting for NodePort to be accessible on the new pod")
 			gomega.Eventually(func() error {
-				if err := checkHTTPHealthReady(nodePort, 2*time.Second); err != nil {
+				if err := checkHTTPHealthReady(nodePort); err != nil {
 					return fmt.Errorf("nodePort %d not ready after restart: %w", nodePort, err)
 				}
 				return nil
@@ -374,7 +374,7 @@ var _ = ginkgo.Describe("MCPServer Cross-Replica Session Routing with Redis", fu
 			redisName = fmt.Sprintf("e2e-redis-%d", ts)
 
 			ginkgo.By("Deploying Redis for session storage")
-			deployRedis(defaultNamespace, redisName, timeout, pollInterval)
+			deployRedis(redisName)
 
 			replicas := int32(2)
 			redisAddr := fmt.Sprintf("%s.%s.svc.cluster.local:6379", redisName, defaultNamespace)
@@ -413,7 +413,7 @@ var _ = ginkgo.Describe("MCPServer Cross-Replica Session Routing with Redis", fu
 			_ = k8sClient.Delete(ctx, &mcpv1alpha1.MCPServer{
 				ObjectMeta: metav1.ObjectMeta{Name: mcpServerName, Namespace: defaultNamespace},
 			})
-			cleanupRedis(defaultNamespace, redisName)
+			cleanupRedis(redisName)
 
 			gomega.Eventually(func() bool {
 				err := k8sClient.Get(ctx, types.NamespacedName{Name: mcpServerName, Namespace: defaultNamespace}, &mcpv1alpha1.MCPServer{})