test: add unit tests for file extension filtering and path conversion

- Introduced tests to verify that excluded file extensions are correctly identified as irrelevant.
- Added tests to ensure that multi-dot file extensions are handled properly, only matching the last segment.
- Implemented a test to confirm that paths are converted from Windows to Unix format while preserving drive letters.
- Added a test to check that symlink loops do not cause infinite recursion during directory scanning.

Author: gramistella

tests/fs_event_filtering_ext.rs

@@ -0,0 +1,28 @@
+use std::collections::HashSet;
+use stitch::core::is_event_path_relevant;
+use tempfile::TempDir;
+
+#[test]
+fn excluded_extension_is_not_relevant() {
+    let tmp = TempDir::new().unwrap();
+    let root = tmp.path().to_path_buf();
+
+    let p = root.join("note.LOG");
+
+    let include_exts: HashSet<String> = HashSet::new();
+    let exclude_exts: HashSet<String> = std::iter::once(String::from(".log")).collect();
+    let exclude_dirs: HashSet<String> = HashSet::new();
+    let exclude_files: HashSet<String> = HashSet::new();
+
+    assert!(
+        !is_event_path_relevant(
+            &root,
+            &p,
+            &include_exts,
+            &exclude_exts,
+            &exclude_dirs,
+            &exclude_files
+        ),
+        "excluded extension should not be relevant (case-insensitive)"
+    );
+}

tests/multidot_extension_exclude.rs

@@ -0,0 +1,25 @@
+use std::collections::HashSet;
+use std::fs;
+use stitch::core::scan_dir_to_node;
+use tempfile::TempDir;
+
+#[test]
+fn exclude_multidot_matches_last_segment_only() {
+    let tmp = TempDir::new().unwrap();
+    let root = tmp.path();
+    fs::write(root.join("archive.tar.gz"), "x").unwrap();
+
+    let include: HashSet<String> = HashSet::new();
+    let exclude_tar_gz: HashSet<String> = std::iter::once(String::from(".tar.gz")).collect();
+    let exclude_gz: HashSet<String> = std::iter::once(String::from(".gz")).collect();
+    let nodirs = HashSet::new();
+    let nofiles = HashSet::new();
+
+    // Excluding ".tar.gz" should NOT hide it if only the last segment is considered.
+    let tree1 = scan_dir_to_node(root, &include, &exclude_tar_gz, &nodirs, &nofiles);
+    assert!(tree1.children.iter().any(|n| n.name == "archive.tar.gz"));
+
+    // Excluding ".gz" should hide it.
+    let tree2 = scan_dir_to_node(root, &include, &exclude_gz, &nodirs, &nofiles);
+    assert!(!tree2.children.iter().any(|n| n.name == "archive.tar.gz"));
+}

tests/path_to_unix_windows.rs

@@ -0,0 +1,17 @@
+#[cfg(windows)]
+#[test]
+fn path_to_unix_converts_backslashes_and_keeps_drive() {
+    use std::path::PathBuf;
+    use stitch::core::path_to_unix;
+
+    let p = PathBuf::from(r"C:\projects\stitch\src\lib.rs");
+    let s = path_to_unix(&p);
+    assert!(
+        s.contains("C:"),
+        "drive letter should be preserved in lossy path"
+    );
+    assert!(
+        s.ends_with("projects/stitch/src/lib.rs"),
+        "backslashes should become slashes"
+    );
+}

tests/profile_load_precedence.rs

@@ -0,0 +1,53 @@
+use stitch::core::{
+    Profile, ProfileScope, RustOptions, SlintOptions, WorkspaceSettings, load_profile, save_profile,
+};
+use tempfile::TempDir;
+
+const fn ws() -> WorkspaceSettings {
+    WorkspaceSettings {
+        version: 1,
+        ext_filter: String::new(),
+        exclude_dirs: String::new(),
+        exclude_files: String::new(),
+        remove_prefix: String::new(),
+        remove_regex: String::new(),
+        hierarchy_only: false,
+        dirs_only: false,
+        rust: RustOptions {
+            rust_remove_inline_comments: false,
+            rust_remove_doc_comments: false,
+            rust_function_signatures_only: false,
+            rust_signatures_only_filter: String::new(),
+        },
+        slint: SlintOptions {
+            slint_remove_line_comments: false,
+            slint_remove_block_comments: false,
+        },
+    }
+}
+
+#[test]
+fn load_profile_prefers_local_over_shared() {
+    let tmp = TempDir::new().unwrap();
+    let root = tmp.path();
+
+    let mut shared = Profile {
+        name: "same".into(),
+        settings: ws(),
+        explicit: vec![],
+    };
+    shared.settings.ext_filter = ".rs".into();
+    save_profile(root, &shared, ProfileScope::Shared).unwrap();
+
+    let mut local = Profile {
+        name: "same".into(),
+        settings: ws(),
+        explicit: vec![],
+    };
+    local.settings.ext_filter = ".md".into();
+    save_profile(root, &local, ProfileScope::Local).unwrap();
+
+    let (loaded, scope) = load_profile(root, "same").expect("load");
+    assert_eq!(scope, ProfileScope::Local);
+    assert_eq!(loaded.settings.ext_filter, ".md");
+}

tests/render_without_root.rs

@@ -0,0 +1,10 @@
+use stitch::core::render_unicode_tree_from_paths;
+
+#[test]
+fn render_without_root_has_no_top_line() {
+    let paths = vec!["a/b.rs".into(), "a/c.rs".into(), "d.txt".into()];
+    let out = render_unicode_tree_from_paths(&paths, None);
+    // Just ensure it starts with the first top-level dir/file and ends with a newline.
+    assert!(out.starts_with("├── a\n") || out.starts_with("└── d.txt\n"));
+    assert!(out.ends_with('\n'));
+}

tests/scan_symlink_loop.rs

@@ -0,0 +1,30 @@
+#[cfg(unix)]
+#[test]
+fn scanner_does_not_follow_symlink_loops() {
+    use std::collections::HashSet;
+    use std::fs;
+    use std::os::unix::fs::symlink;
+    use stitch::core::scan_dir_to_node;
+    use tempfile::TempDir;
+
+    let tmp = TempDir::new().unwrap();
+    let root = tmp.path();
+
+    fs::create_dir_all(root.join("real")).unwrap();
+    fs::write(root.join("real/file.txt"), "x").unwrap();
+    // Create loop: real/loop -> real
+    symlink(root.join("real"), root.join("real/loop")).unwrap();
+
+    let h = HashSet::new();
+    let tree = scan_dir_to_node(root, &h, &h, &h, &h);
+
+    // Expect: "real" present, "file.txt" present, but not an endlessly nested "loop" chain.
+    let real = tree.children.iter().find(|n| n.name == "real").unwrap();
+    assert!(real.children.iter().any(|n| n.name == "file.txt"));
+    // Either "loop" is omitted, or included once but not infinitely expanded.
+    let loop_count = real.children.iter().filter(|n| n.name == "loop").count();
+    assert!(
+        loop_count <= 1,
+        "symlink loop must not cause unbounded descent"
+    );
+}