test: cover high-value scanners, webdav, and editor composables

Add frontend tests for project editor, auto-scanner settings, and
keyboard navigation. Expand Rust coverage for JetBrains/VS Code recent
history, analyzer path helpers, and WebDAV upload/URL helpers. Fix
$USER_HOME$ recent-path filtering and WebDAV double-slash URL joins
uncovered by the new tests.

Author: MidnightCrowing

src-tauri/src/analyzer/paths.rs

@@ -29,3 +29,58 @@ pub fn strip_windows_verbatim_prefix(path: &str) -> String {
     }
     path.to_string()
 }
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use super::{
+        canonical_or_original, display_path, normalize_path_key, strip_windows_verbatim_prefix,
+    };
+
+    #[test]
+    fn strip_windows_verbatim_prefix_removes_drive_and_unc_prefixes() {
+        assert_eq!(
+            strip_windows_verbatim_prefix(r"\\?\E:\Projects\CodeNest"),
+            r"E:\Projects\CodeNest"
+        );
+        assert_eq!(
+            strip_windows_verbatim_prefix(r"\\?\UNC\server\share\CodeNest"),
+            r"\\server\share\CodeNest"
+        );
+        assert_eq!(
+            strip_windows_verbatim_prefix(r"E:\Projects\CodeNest"),
+            r"E:\Projects\CodeNest"
+        );
+    }
+
+    #[test]
+    fn normalize_path_key_unifies_slashes_and_trims_trailing_separators() {
+        let key = normalize_path_key(Path::new(r"E:\Projects\CodeNest\"));
+        assert!(!key.ends_with('/'));
+        assert!(key.contains("Projects") || key.contains("projects"));
+        assert!(key.contains('/'));
+        assert!(!key.contains('\\'));
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn normalize_path_key_lowercases_on_windows() {
+        let key = normalize_path_key(Path::new(r"E:\Projects\CodeNest"));
+        assert_eq!(key, key.to_ascii_lowercase());
+    }
+
+    #[test]
+    fn display_path_strips_verbatim_prefix() {
+        assert_eq!(
+            display_path(Path::new(r"\\?\E:\Projects\CodeNest")),
+            r"E:\Projects\CodeNest"
+        );
+    }
+
+    #[test]
+    fn canonical_or_original_keeps_missing_paths() {
+        let missing = Path::new(r"E:\definitely-missing-codenest-path-xyz");
+        assert_eq!(canonical_or_original(missing), missing.to_path_buf());
+    }
+}

src-tauri/src/recent/jetbrains.rs

@@ -49,13 +49,15 @@ pub fn collect_from_jetbrains(config_root: Option<&str>) -> Vec<RecentProject> {
                 let Some(raw_path) = project_entry.attribute("key") else {
                     continue;
                 };
-                if raw_path.contains('$')
-                    || raw_path.contains("light-edit")
-                    || raw_path.contains("scratches")
-                {
+                // light-edit / scratches are transient JetBrains workspaces.
+                // Expand $USER_HOME$ first, then drop any still-unresolved macros.
+                if raw_path.contains("light-edit") || raw_path.contains("scratches") {
                     continue;
                 }
                 let normalized = normalize_jetbrains_path(raw_path, &home);
+                if normalized.contains('$') {
+                    continue;
+                }
                 candidates.push(RecentProject {
                     path: normalized,
                     ide: ide.clone(),
@@ -92,3 +94,142 @@ fn map_jetbrains_ide(raw_name: &str) -> Option<String> {
     };
     Some(value.to_string())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        fs,
+        path::Path,
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    use crate::analyzer::normalize_path_key;
+
+    use super::{collect_from_jetbrains, map_jetbrains_ide, normalize_jetbrains_path};
+
+    fn unique_temp_dir(label: &str) -> std::path::PathBuf {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be valid")
+            .as_nanos();
+        std::env::temp_dir().join(format!(
+            "codenest-jetbrains-{label}-{}-{unique}",
+            std::process::id()
+        ))
+    }
+
+    fn write_recent_projects_xml(product_dir: &Path, entries: &[&str]) {
+        let options_dir = product_dir.join("options");
+        fs::create_dir_all(&options_dir).expect("options dir should be created");
+        let mut body = String::from(
+            r#"<application><component name="RecentProjectsManager"><option name="additionalInfo"><map>"#,
+        );
+        for entry in entries {
+            body.push_str(&format!(r#"<entry key="{entry}"/>"#));
+        }
+        body.push_str("</map></option></component></application>");
+        fs::write(options_dir.join("recentProjects.xml"), body)
+            .expect("recentProjects.xml should be written");
+    }
+
+    #[test]
+    fn collect_from_jetbrains_returns_empty_for_missing_root() {
+        assert!(collect_from_jetbrains(None).is_empty());
+        assert!(collect_from_jetbrains(Some("")).is_empty());
+        assert!(collect_from_jetbrains(Some(
+            r"E:\definitely-missing-jetbrains-config-root"
+        ))
+        .is_empty());
+    }
+
+    #[test]
+    fn map_jetbrains_ide_recognizes_common_products() {
+        assert_eq!(
+            map_jetbrains_ide("IntelliJIdea").as_deref(),
+            Some("intellij-idea")
+        );
+        assert_eq!(map_jetbrains_ide("WebStorm").as_deref(), Some("webstorm"));
+        assert_eq!(map_jetbrains_ide("GoLand").as_deref(), Some("goLand"));
+        assert_eq!(map_jetbrains_ide("UnknownIde"), None);
+    }
+
+    #[test]
+    fn normalize_jetbrains_path_expands_user_home() {
+        let home = Path::new(r"C:\Users\example");
+        let normalized = normalize_jetbrains_path("$USER_HOME$/Projects/CodeNest", home);
+        #[cfg(windows)]
+        assert_eq!(normalized, r"C:\Users\example\Projects\CodeNest");
+        #[cfg(not(windows))]
+        assert_eq!(normalized, "C:\\Users\\example/Projects/CodeNest");
+    }
+
+    #[test]
+    fn collect_from_jetbrains_reads_existing_projects_and_skips_transients() {
+        let root = unique_temp_dir("collect");
+        let config_root = root.join("config");
+        let project = root.join("project_a");
+        fs::create_dir_all(&project).expect("project dir should be created");
+        fs::create_dir_all(&config_root).expect("config root should be created");
+
+        let product_dir = config_root.join("WebStorm2024.1");
+        let project_key = project.to_string_lossy().replace('\\', "/");
+        write_recent_projects_xml(
+            &product_dir,
+            &[
+                project_key.as_str(),
+                "$USER_HOME$/light-edit",
+                "/tmp/scratches/demo",
+                "$APPLICATION_CONFIG_DIR$/system",
+            ],
+        );
+
+        let items = collect_from_jetbrains(Some(&config_root.to_string_lossy()));
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0].ide.as_deref(), Some("webstorm"));
+        assert_eq!(
+            normalize_path_key(Path::new(&items[0].path)),
+            normalize_path_key(&project)
+        );
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn collect_from_jetbrains_expands_user_home_macro() {
+        let home = dirs::home_dir().expect("home dir should exist for jetbrains macro test");
+        let project = home.join(format!(
+            "codenest-jetbrains-home-project-{}-{}",
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .expect("system time should be valid")
+                .as_nanos()
+        ));
+        fs::create_dir_all(&project).expect("home project dir should be created");
+
+        let root = unique_temp_dir("home-macro");
+        let config_root = root.join("config");
+        fs::create_dir_all(&config_root).expect("config root should be created");
+        let product_dir = config_root.join("IntelliJIdea2023.3");
+        let relative = project
+            .strip_prefix(&home)
+            .expect("project should be under home")
+            .to_string_lossy()
+            .replace('\\', "/");
+        write_recent_projects_xml(
+            &product_dir,
+            &[&format!("$USER_HOME$/{relative}")],
+        );
+
+        let items = collect_from_jetbrains(Some(&config_root.to_string_lossy()));
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0].ide.as_deref(), Some("intellij-idea"));
+        assert_eq!(
+            normalize_path_key(Path::new(&items[0].path)),
+            normalize_path_key(&project)
+        );
+
+        let _ = fs::remove_dir_all(project);
+        let _ = fs::remove_dir_all(root);
+    }
+}

src-tauri/src/recent/vscode.rs

@@ -97,7 +97,10 @@ struct VscodeRecentEntry {
 #[derive(Deserialize)]
 #[serde(untagged)]
 enum VscodeWorkspace {
-    Object { config_path: String },
+    Object {
+        #[serde(rename = "configPath")]
+        config_path: String,
+    },
     String(String),
 }
 
@@ -109,3 +112,143 @@ impl VscodeWorkspace {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        fs,
+        path::{Path, PathBuf},
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    use rusqlite::Connection;
+    use serde_json::json;
+
+    use crate::analyzer::normalize_path_key;
+
+    use super::collect_from_vscode;
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be valid")
+            .as_nanos();
+        std::env::temp_dir().join(format!(
+            "codenest-vscode-{label}-{}-{unique}",
+            std::process::id()
+        ))
+    }
+
+    fn path_to_file_uri(path: &Path) -> String {
+        let url = url::Url::from_file_path(path).expect("path should convert to file uri");
+        url.into()
+    }
+
+    fn write_vscdb(db_path: &Path, history_json: &str) {
+        if let Some(parent) = db_path.parent() {
+            fs::create_dir_all(parent).expect("db parent should be created");
+        }
+        let connection = Connection::open(db_path).expect("sqlite db should open");
+        connection
+            .execute(
+                "CREATE TABLE ItemTable (key TEXT PRIMARY KEY, value TEXT)",
+                [],
+            )
+            .expect("ItemTable should be created");
+        connection
+            .execute(
+                "INSERT INTO ItemTable (key, value) VALUES (?1, ?2)",
+                ("history.recentlyOpenedPathsList", history_json),
+            )
+            .expect("history row should be inserted");
+    }
+
+    #[test]
+    fn collect_from_vscode_returns_empty_for_missing_db() {
+        assert!(collect_from_vscode(None).is_empty());
+        assert!(collect_from_vscode(Some("")).is_empty());
+        assert!(collect_from_vscode(Some(r"E:\missing-state.vscdb")).is_empty());
+    }
+
+    #[test]
+    fn collect_from_vscode_reads_folder_file_and_workspace_entries() {
+        let root = unique_temp_dir("entries");
+        let project = root.join("project");
+        let file_project = root.join("file-project");
+        let workspace_project = root.join("workspace-project");
+        fs::create_dir_all(&project).expect("project dir should be created");
+        fs::create_dir_all(&file_project).expect("file project dir should be created");
+        fs::create_dir_all(&workspace_project).expect("workspace project dir should be created");
+
+        let file_uri = path_to_file_uri(&file_project.join("main.ts"));
+        let workspace_uri = path_to_file_uri(&workspace_project.join("demo.code-workspace"));
+        let history = json!({
+            "entries": [
+                { "folderUri": path_to_file_uri(&project) },
+                { "fileUri": file_uri },
+                { "workspace": { "configPath": workspace_uri } },
+                {
+                    "folderUri": path_to_file_uri(&root.join("remote-only")),
+                    "remoteAuthority": "ssh-remote+devbox"
+                }
+            ]
+        })
+        .to_string();
+
+        let db_path = root.join("state.vscdb");
+        write_vscdb(&db_path, &history);
+
+        let mut items = collect_from_vscode(Some(&db_path.to_string_lossy()));
+        items.sort_by(|a, b| a.path.cmp(&b.path));
+
+        let paths: Vec<_> = items
+            .iter()
+            .map(|item| normalize_path_key(Path::new(&item.path)))
+            .collect();
+
+        assert!(paths.contains(&normalize_path_key(&project)));
+        assert!(paths.contains(&normalize_path_key(&file_project)));
+        assert!(paths.contains(&normalize_path_key(&workspace_project)));
+        assert_eq!(items.len(), 3);
+        assert!(items.iter().all(|item| item.ide.is_none()));
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn collect_from_vscode_accepts_string_workspace_entries() {
+        let root = unique_temp_dir("workspace-string");
+        let workspace_project = root.join("ws");
+        fs::create_dir_all(&workspace_project).expect("workspace dir should be created");
+        let workspace_uri = path_to_file_uri(&workspace_project.join("app.code-workspace"));
+        let history = json!({
+            "entries": [
+                { "workspace": workspace_uri }
+            ]
+        })
+        .to_string();
+
+        let db_path = root.join("state.vscdb");
+        write_vscdb(&db_path, &history);
+
+        let items = collect_from_vscode(Some(&db_path.to_string_lossy()));
+        assert_eq!(items.len(), 1);
+        assert_eq!(
+            normalize_path_key(Path::new(&items[0].path)),
+            normalize_path_key(&workspace_project)
+        );
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn collect_from_vscode_returns_empty_for_invalid_history_json() {
+        let root = unique_temp_dir("invalid-json");
+        let db_path = root.join("state.vscdb");
+        write_vscdb(&db_path, "{not-json");
+
+        assert!(collect_from_vscode(Some(&db_path.to_string_lossy())).is_empty());
+
+        let _ = fs::remove_dir_all(root);
+    }
+}