chore: a few more tests

Author: kainlite

src/forward.rs

@@ -139,7 +139,7 @@ impl PortForward {
         Ok(())
     }
 
-    async fn monitor_connection(&self, client: &Client) -> Result<()> {
+    pub async fn monitor_connection(&self, client: &Client) -> Result<()> {
         let health_check = HealthCheck::new();
         let mut interval = tokio::time::interval(self.config.options.health_check_interval);
 
@@ -172,7 +172,7 @@ impl PortForward {
         }
     }
 
-    async fn establish_forward(&self, client: &Client) -> Result<()> {
+    pub async fn establish_forward(&self, client: &Client) -> Result<()> {
         self.metrics.record_connection_attempt();
         // Get pod for the service
         let pod = self.get_pod(client).await?;
@@ -269,7 +269,7 @@ impl PortForward {
         Ok(())
     }
 
-    async fn forward_connection(
+    pub async fn forward_connection(
         pods: &Api<Pod>,
         pod_name: String,
         port: u16,
@@ -323,7 +323,7 @@ impl PortForward {
         Ok(())
     }
 
-    async fn get_pod(&self, client: &Client) -> Result<Pod> {
+    pub async fn get_pod(&self, client: &Client) -> Result<Pod> {
         let pods: Api<Pod> = Api::namespaced(client.clone(), &self.service_info.namespace);
 
         // Get all pods in the namespace

tests/forward_tests.rs

@@ -216,4 +216,182 @@ mod tests {
         let mut rx = forward.shutdown.subscribe();
         assert!(rx.try_recv().is_err()); // Should be empty after stop
     }
+
+    // This tests specifically depends on kind
+    // just a reminder in case it fails later on
+    #[tokio::test]
+    async fn test_establish_forward() {
+        let config = ForwardConfig {
+            name: "test-forward".to_string(),
+            target: "test-target.test-namespace".to_string(),
+            ports: kube_forward::config::PortMapping {
+                local: 0, // Use port 0 to let OS assign random port
+                remote: 80,
+            },
+            pod_selector: PodSelector {
+                label: None,
+                annotation: None,
+            },
+            local_dns: kube_forward::config::LocalDnsConfig {
+                enabled: false,
+                hostname: None,
+            },
+            options: kube_forward::config::ForwardOptions {
+                max_retries: 3,
+                retry_interval: Duration::from_secs(1),
+                health_check_interval: Duration::from_secs(5),
+            },
+        };
+
+        let service_info = ServiceInfo {
+            name: "kube-dns".to_string(),
+            namespace: "kube-system".to_string(),
+            ports: vec![53],
+        };
+
+        let forward = PortForward::new(config, service_info);
+        let client = kube::Client::try_default().await.unwrap();
+
+        // Test port already in use
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+
+        let mut config_with_used_port = forward.config.clone();
+        config_with_used_port.ports.local = port;
+        let forward_with_used_port =
+            PortForward::new(config_with_used_port, forward.service_info.clone());
+
+        let result = forward_with_used_port.establish_forward(&client).await;
+        assert!(result.is_err());
+        match result {
+            Err(kube_forward::error::PortForwardError::ConnectionError(msg)) => {
+                assert!(msg.contains("already in use"));
+            }
+            _ => panic!("Expected ConnectionError for port in use"),
+        }
+    }
+
+    // This tests specifically depends on kind
+    // just a reminder in case it fails later on
+    #[tokio::test]
+    async fn test_monitor_connection() {
+        let config = ForwardConfig {
+            name: "kube-dns".to_string(),
+            target: "kube-dns.kube-system".to_string(),
+            ports: kube_forward::config::PortMapping {
+                local: 53,
+                remote: 53,
+            },
+            pod_selector: PodSelector {
+                label: None,
+                annotation: None,
+            },
+            local_dns: kube_forward::config::LocalDnsConfig {
+                enabled: false,
+                hostname: None,
+            },
+            options: kube_forward::config::ForwardOptions {
+                max_retries: 3,
+                retry_interval: Duration::from_secs(1),
+                health_check_interval: Duration::from_millis(100), // Use shorter interval for testing
+            },
+        };
+
+        let service_info = ServiceInfo {
+            name: "kube-dns".to_string(),
+            namespace: "kube-system".to_string(),
+            ports: vec![53],
+        };
+
+        let mut forward = PortForward::new(config, service_info);
+        let client = kube::Client::try_default().await.unwrap();
+
+        // Create a listener that we'll close to simulate connection failure
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+        forward.config.ports.local = port;
+
+        // Start monitoring in a separate task
+        let monitor_handle = tokio::spawn({
+            let forward = forward.clone();
+            let client = client.clone();
+            async move { forward.monitor_connection(&client).await }
+        });
+
+        // Wait a bit to ensure monitoring has started
+        tokio::time::sleep(Duration::from_millis(50)).await;
+
+        // Close the listener to simulate connection failure
+        drop(listener);
+
+        // Wait for the monitor to detect the failure
+        let result = monitor_handle.await.unwrap();
+        assert!(result.is_err());
+        match result {
+            Err(kube_forward::error::PortForwardError::ConnectionError(msg)) => {
+                assert!(msg.contains("Connection health check failed"));
+            }
+            _ => panic!("Expected ConnectionError for health check failure"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_forward_connection() {
+        let pods: kube::Api<Pod> =
+            kube::Api::namespaced(kube::Client::try_default().await.unwrap(), "default");
+
+        // Create a mock TCP connection
+        let (client_conn, _server_conn) = tokio::io::duplex(64);
+
+        // Test the forward_connection function
+        let result =
+            PortForward::forward_connection(&pods, "test-pod".to_string(), 80, client_conn).await;
+
+        // Since we're not in a real k8s environment, this should fail
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn test_get_pod() {
+        let config = ForwardConfig {
+            name: "test-forward".to_string(),
+            target: "test-target.test-namespace".to_string(),
+            ports: kube_forward::config::PortMapping {
+                local: 8080,
+                remote: 80,
+            },
+            pod_selector: PodSelector {
+                label: Some("app=test".to_string()),
+                annotation: None,
+            },
+            local_dns: kube_forward::config::LocalDnsConfig {
+                enabled: false,
+                hostname: None,
+            },
+            options: kube_forward::config::ForwardOptions {
+                max_retries: 3,
+                retry_interval: Duration::from_secs(1),
+                health_check_interval: Duration::from_secs(5),
+            },
+        };
+
+        let service_info = ServiceInfo {
+            name: "test-service".to_string(),
+            namespace: "default".to_string(),
+            ports: vec![80],
+        };
+
+        let forward = PortForward::new(config, service_info);
+        let client = kube::Client::try_default().await.unwrap();
+
+        // Test get_pod without a real cluster
+        let result = forward.get_pod(&client).await;
+        assert!(result.is_err());
+        match result {
+            Err(kube_forward::error::PortForwardError::ConnectionError(msg)) => {
+                assert!(msg.contains("No ready pods found"));
+            }
+            _ => panic!("Expected ConnectionError for no pods found"),
+        }
+    }
 }