refactor(server): extract interval constants and add process monitor tests

Extract hardcoded intervals into constants for better maintainability and add comprehensive tests for process monitoring functionality. The tests verify proper behavior of process refresh kind configurations and memory info accessibility.

Author: hackerzhuli

src/monitor.rs

@@ -272,4 +272,70 @@ pub(crate) fn extract_hot_reload_project_path(process: &sysinfo::Process) -> Opt
 fn process_refresh_kind() -> ProcessRefreshKind {
     // we need nothing, no cpu, no memory, just basics
     ProcessRefreshKind::nothing().with_exe(UpdateKind::Always).with_cmd(UpdateKind::Always)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use sysinfo::{System, ProcessRefreshKind, UpdateKind};
+
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_process_refresh_kind_parent_id_accessible() {
+        // Create a system and refresh with our specific ProcessRefreshKind
+        let mut system = System::new();
+        let refresh_kind = ProcessRefreshKind::nothing();
+        
+        // Refresh processes with our specific refresh kind
+        system.refresh_processes_specifics(
+            sysinfo::ProcessesToUpdate::All,
+            true,
+            refresh_kind
+        );
+        
+        // Find any process that has a parent (most processes should have one)
+        let mut found_process_with_parent = false;
+        
+        for (_pid, process) in system.processes() {
+            // Verify parent_id is accessible even though we didn't explicitly request it
+            if process.parent().is_some() {
+                found_process_with_parent = true;
+            }
+
+            // Verify that memory info is not detailed (we didn't request memory refresh)
+            assert!(process.memory() == 0, "memory should be 0");
+        }
+        
+        // Assert that we found at least one process with a parent
+        // This verifies that parent_id is accessible even without explicit request
+        assert!(found_process_with_parent, "Should find at least one process with a parent ID");
+        
+        // The test verifies that:
+        // 1. parent_id is accessible (found_process_with_parent = true)
+        // 2. We only requested exe and cmd info, not CPU or detailed memory
+        // 3. The ProcessRefreshKind configuration works as expected
+    }
+
+    #[test]
+    fn test_process_refresh_kind_memory_info() {
+        // Create a system and refresh with our specific ProcessRefreshKind
+        let mut system = System::new();
+        let refresh_kind = ProcessRefreshKind::nothing().with_memory();
+        
+        // Refresh processes with our specific refresh kind
+        system.refresh_processes_specifics(
+            sysinfo::ProcessesToUpdate::All,
+            true,
+            refresh_kind
+        );
+        
+        let mut sum_memory:u64 = 0;
+
+        for (_pid, process) in system.processes() {
+            // Verify that memory info is detailed
+            sum_memory += process.memory();
+        }
+
+        assert!(sum_memory > 1000000000, "sum memory should be greater than 1000000000");
+    }
 }

src/server.rs

@@ -66,9 +66,17 @@ pub struct SymbolDocsResponse {
     pub inherited_from_symbol_name: Option<String>,
 }
 
-// Time interval for periodic detect Unity when Unity is not yet detected
+/// Time interval for periodic detect Unity when Unity is not yet detected
+/// Note that it takes 30 seconds or more to start Unity Editor, so we don't need to detect Unity too frequently
 const DETECT_UNITY_INTERVAL: Duration = Duration::from_secs(10);
 
+/// Time interval for cleaning up inactive clients
+const CLEANUP_INTERVAL: Duration = Duration::from_secs(5);
+
+/// Time interval for monitoring Unity processes
+/// Typically this will not do all processes refresh, only refresh processes that we care about and already detected
+const MONITOR_INTERVAL: Duration = Duration::from_millis(500);
+
 struct ClientInfo {
     last_message_time: Instant,
 }
@@ -106,8 +114,8 @@ impl Server {
 
     pub async fn run(&mut self) {
         let mut buffer = [0u8; 1024];
-        let mut cleanup_interval = interval(Duration::from_secs(5));
-        let mut monitor_interval = interval(Duration::from_millis(100));
+        let mut cleanup_interval = interval(CLEANUP_INTERVAL);
+        let mut monitor_interval = interval(MONITOR_INTERVAL);
 
         loop {
             tokio::select! {