Added more integration tests

Author: hollowpointer

tests/src/discovery/mod.rs

@@ -0,0 +1,14 @@
+// Copyright (c) 2026 OverTheFlow and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at
+// https://mozilla.org/MPL/2.0/.
+
+//! High-level host and service discovery tests.
+//!
+//! These tests verify Zond's ability to identify live hosts across various
+//! network environments using both unprivileged (TCP sweeps) and
+//! privileged (ARP/ICMP) techniques.
+
+pub mod unprivileged;
+pub mod privileged;

tests/src/discovery/privileged.rs

@@ -0,0 +1,135 @@
+// Copyright (c) 2026 OverTheFlow and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at
+// https://mozilla.org/MPL/2.0/.
+
+use std::net::{IpAddr, Ipv4Addr};
+use zond_common::config::ZondConfig;
+use zond_common::models::ip::set::IpSet;
+use zond_core::scanner;
+
+#[cfg(target_os = "linux")]
+use crate::utils::NetnsContext;
+
+#[tokio::test]
+#[cfg(target_os = "linux")]
+async fn test_privileged_discovery_netns() {
+    let _ctx: NetnsContext = match NetnsContext::new("test1") {
+        Some(c) => c,
+        None => {
+            eprintln!("Skipping netns test: Requires root privileges or 'ip' command.");
+            return;
+        }
+    };
+
+    let target_ip: IpAddr = IpAddr::V4(Ipv4Addr::new(10, 200, 0, 2));
+
+    let config: ZondConfig = ZondConfig {
+        no_banner: true,
+        no_dns: true,
+        redact: false,
+        quiet: 0,
+        disable_input: true,
+    };
+
+    let mut collection = IpSet::new();
+    collection.insert(target_ip);
+
+    let result = scanner::discover(collection, &config).await;
+
+    match result {
+        Ok(hosts) => {
+            assert!(!hosts.is_empty(), "Should find the target in the namespace");
+            let host = hosts
+                .iter()
+                .find(|h| h.primary_ip == target_ip)
+                .expect("Target IP not found in results");
+
+            assert!(
+                host.mac.is_some(),
+                "Should resolve MAC address for local neighbor"
+            );
+            println!("Found host: {:?} with MAC {:?}", host.primary_ip, host.mac);
+        }
+        Err(e) => panic!("Discovery failed: {}", e),
+    }
+}
+
+#[tokio::test]
+#[cfg(target_os = "linux")]
+async fn test_privileged_discovery_hostname_resolution() {
+    let ctx: NetnsContext = match NetnsContext::new("res-test") {
+        Some(c) => c,
+        None => return,
+    };
+
+    // Set a custom hostname inside the namespace
+    // Note: This requires the machine running the test to support 'ip netns exec'
+    let _ = crate::utils::netns::run_ns_cmd(&ctx.ns_name, "hostname", &["zond-target-host"]);
+
+    // Start a listener on 443 inside the namespace so 'discover' finds it
+    // We'll use a sidecar thread running 'nc' since it's easier than async-pipe logic for a quick mock.
+    let ns_name = ctx.ns_name.clone();
+    std::thread::spawn(move || {
+        let _ = crate::utils::netns::run_ns_cmd(&ns_name, "nc", &["-l", "-p", "443", "-e", "echo hello"]);
+    });
+
+    let target_ip: IpAddr = IpAddr::V4(Ipv4Addr::new(10, 200, 0, 2));
+    let config: ZondConfig = ZondConfig {
+        no_banner: true,
+        no_dns: false, // Enable DNS
+        redact: false,
+        quiet: 0,
+        disable_input: true,
+    };
+
+    let mut collection = IpSet::new();
+    collection.insert(target_ip);
+
+    let result = scanner::discover(collection, &config).await;
+    assert!(result.is_ok());
+    let hosts = result.unwrap();
+
+    if !hosts.is_empty() {
+        let host = &hosts[0];
+        println!("Resolved host: {:?} - Hostname: {:?}", host.primary_ip, host.hostname);
+        // On many systems, the namespace hostname won't resolve unless /etc/hosts is updated or a DNS server is present.
+        // For now, we verify that the scan COMPLETE safely with resolution enabled.
+    }
+}
+
+#[tokio::test]
+#[cfg(target_os = "linux")]
+async fn test_privileged_discovery_stress_multi_alias() {
+    let ctx: NetnsContext = match NetnsContext::new("stress-test") {
+        Some(c) => c,
+        None => return,
+    };
+
+    // Add 20 alias IPs to the namespace interface (v-targ-stress-test)
+    for i in 3..23 {
+        let ip = format!("10.200.0.{}", i);
+        let _ = crate::utils::netns::run_ns_cmd(&ctx.ns_name, "ip", &["addr", "add", &format!("{}/24", ip), "dev", "v-targ-stress-test"]);
+    }
+
+    let config: ZondConfig = ZondConfig {
+        no_banner: true,
+        no_dns: true,
+        redact: false,
+        quiet: 0,
+        disable_input: true,
+    };
+
+    let mut collection = IpSet::new();
+    collection.insert_range("10.200.0.1-10.200.0.30".parse().unwrap());
+
+    // Privileged scanner should use ARP to find all 21 active IPs (host + 20 aliases)
+    let result = scanner::discover(collection, &config).await;
+    assert!(result.is_ok());
+    let hosts = result.unwrap();
+
+    // Should find at least 21 hosts (the target + aliases)
+    // Note: 10.200.0.1 is the host side, so it might also be found depending on routing.
+    assert!(hosts.len() >= 21, "Failed to find all aliased IPs in namespace. Found only: {}", hosts.len());
+}

tests/src/discovery/routed.rs

@@ -4,7 +4,6 @@
 // If a copy of the MPL was not distributed with this file, You can obtain one at
 // https://mozilla.org/MPL/2.0/.
 
-#![cfg(test)]
 use std::net::{IpAddr, Ipv4Addr};
 use std::sync::atomic::Ordering;
 use std::time::Duration;
@@ -13,9 +12,6 @@ use zond_common::models::host::Host;
 use zond_common::models::ip::{range::Ipv4Range, set::IpSet};
 use zond_core::scanner::{self, STOP_SIGNAL};
 
-#[cfg(target_os = "linux")]
-use crate::utils::NetnsContext;
-
 #[tokio::test]
 async fn test_discovery_single_loopback() {
     let config: ZondConfig = ZondConfig {
@@ -107,71 +103,70 @@ async fn test_stop_signal_aborts() {
 }
 
 #[tokio::test]
-#[cfg(target_os = "linux")]
-async fn test_privileged_discovery_netns() {
-    let _ctx: NetnsContext = match NetnsContext::new("test1") {
-        Some(c) => c,
-        None => {
-            eprintln!("Skipping netns test: Requires root privileges or 'ip' command.");
-            return;
-        }
+async fn test_discovery_empty_set() {
+    let cfg: ZondConfig = ZondConfig {
+        no_banner: true,
+        no_dns: true,
+        redact: false,
+        quiet: 0,
+        disable_input: true,
     };
 
-    let target_ip: IpAddr = IpAddr::V4(Ipv4Addr::new(10, 200, 0, 2));
+    let targets = IpSet::new();
+    let result = scanner::discover(targets, &cfg).await;
 
-    let config: ZondConfig = ZondConfig {
+    assert!(result.is_ok());
+    let hosts = result.unwrap();
+    assert!(
+        hosts.is_empty(),
+        "Scanning empty set should return no hosts"
+    );
+}
+
+#[tokio::test]
+async fn test_discovery_redundant_ranges() {
+    let cfg: ZondConfig = ZondConfig {
         no_banner: true,
         no_dns: true,
         redact: false,
         quiet: 0,
         disable_input: true,
     };
 
-    let mut collection = IpSet::new();
-    collection.insert(target_ip);
-
-    let result = scanner::discover(collection, &config).await;
-
-    match result {
-        Ok(hosts) => {
-            assert!(!hosts.is_empty(), "Should find the target in the namespace");
-            let host = hosts
-                .iter()
-                .find(|h| h.primary_ip == target_ip)
-                .expect("Target IP not found in results");
-
-            assert!(
-                host.mac.is_some(),
-                "Should resolve MAC address for local neighbor"
-            );
-            println!("Found host: {:?} with MAC {:?}", host.primary_ip, host.mac);
-        }
-        Err(e) => panic!("Discovery failed: {}", e),
-    }
-}
+    let mut targets = IpSet::new();
+    // Overlapping ranges: 127.0.0.1/31 (1, 2) and 127.0.0.1-5 (1, 2, 3, 4, 5)
+    targets.insert_range("127.0.0.1/31".parse().unwrap());
+    targets.insert_range("127.0.0.1-127.0.0.5".parse().unwrap());
 
-#[test]
-fn test_lan_network_resolution() {
-    // Assert that the machine running the integration test has at least 1 viable interface
-    // that resolves via our platform agnostics hooks (macOS networksetup, Linux sysfs, Windows GetIfTable2).
-    let result = zond_common::net::interface::get_lan_network();
-    assert!(
-        result.is_ok(),
-        "Expected no OS or Viability errors during interface parsing"
-    );
+    // IpSet should have merged these into a single range of 6 IPs (0-5)
+    assert_eq!(targets.len(), 6);
 
-    // Virtualized headless CI runners might return None here since they use virtual bridges,
-    // but the FFI/Syscalls must execute safely regardless!
-    println!("Resolved LAN network: {:?}", result.unwrap());
+    let result = scanner::discover(targets, &cfg).await;
+    assert!(result.is_ok());
 }
 
-#[test]
-fn test_prioritized_interfaces_resolution() {
-    let interfaces_res = zond_common::net::interface::get_prioritized_interfaces(10);
-    assert!(interfaces_res.is_ok());
-    let interfaces = interfaces_res.unwrap();
+#[tokio::test]
+async fn test_discovery_loopback_stress() {
+    let cfg: ZondConfig = ZondConfig {
+        no_banner: true,
+        no_dns: true,
+        redact: false,
+        quiet: 0,
+        disable_input: true,
+    };
+
+    let mut targets = IpSet::new();
+    targets.insert_range("127.0.0.0/24".parse().unwrap());
+
+    let start = std::time::Instant::now();
+    let result = scanner::discover(targets, &cfg).await;
+    let elapsed = start.elapsed();
+
+    assert!(result.is_ok());
+    println!("Sweep of 256 IPs took {}ms", elapsed.as_millis());
+
     assert!(
-        !interfaces.is_empty(),
-        "Expected at least 1 UP, non-loopback network interface on the host natively"
+        elapsed < Duration::from_secs(5),
+        "Sweep took too long, concurrency might be broken"
     );
 }