test: improve test coverage for edge cases (#740)

Author: Boshen

src/cache/borrowed_path.rs

@@ -5,6 +5,7 @@ use std::{
     path::Path,
 };
 
+#[derive(Debug)]
 pub struct BorrowedCachedPath<'a> {
     pub hash: u64,
     pub path: &'a Path,

src/cache/mod.rs

@@ -6,3 +6,40 @@ mod thread_local;
 
 pub use cache_impl::Cache;
 pub use cached_path::CachedPath;
+
+#[cfg(test)]
+mod tests {
+    use super::borrowed_path::BorrowedCachedPath;
+    use super::cache_impl::Cache;
+    use crate::FileSystem;
+    use std::path::Path;
+
+    #[test]
+    fn test_borrowed_cached_path_eq() {
+        let path1 = Path::new("/foo/bar");
+        let path2 = Path::new("/foo/bar");
+        let path3 = Path::new("/foo/baz");
+
+        let borrowed1 = BorrowedCachedPath { hash: 1, path: path1 };
+        let borrowed2 = BorrowedCachedPath { hash: 2, path: path2 };
+        let borrowed3 = BorrowedCachedPath { hash: 1, path: path3 };
+
+        // Same path should be equal even with different hash
+        assert_eq!(borrowed1, borrowed2);
+        // Different path should not be equal even with same hash
+        assert_ne!(borrowed1, borrowed3);
+    }
+
+    #[test]
+    fn test_cached_path_debug() {
+        #[cfg(feature = "yarn_pnp")]
+        let cache = Cache::new(crate::FileSystemOs::new(false));
+        #[cfg(not(feature = "yarn_pnp"))]
+        let cache = Cache::new(crate::FileSystemOs::new());
+
+        let path = cache.value(Path::new("/foo/bar"));
+        let debug_str = format!("{path:?}");
+        assert!(debug_str.contains("FsCachedPath"));
+        assert!(debug_str.contains("path"));
+    }
+}

src/error.rs

@@ -235,3 +235,20 @@ fn test_coverage() {
     assert_eq!(format!("{error:?}"), r#"Specifier(Empty("x"))"#);
     assert_eq!(error.clone(), error);
 }
+
+#[test]
+fn test_circular_path_bufs_display() {
+    use std::path::PathBuf;
+
+    let paths = vec![
+        PathBuf::from("/foo/tsconfig.json"),
+        PathBuf::from("/bar/tsconfig.json"),
+        PathBuf::from("/baz/tsconfig.json"),
+    ];
+    let circular = CircularPathBufs::from(paths);
+    let display_str = format!("{circular}");
+    assert!(display_str.contains("/foo/tsconfig.json"));
+    assert!(display_str.contains(" -> "));
+    assert!(display_str.contains("/bar/tsconfig.json"));
+    assert!(display_str.contains("/baz/tsconfig.json"));
+}

src/file_system.rs

@@ -337,3 +337,21 @@ fn metadata() {
     );
     let _ = meta;
 }
+
+#[test]
+fn file_metadata_getters() {
+    let file_meta = FileMetadata::new(true, false, false);
+    assert!(file_meta.is_file());
+    assert!(!file_meta.is_dir());
+    assert!(!file_meta.is_symlink());
+
+    let dir_meta = FileMetadata::new(false, true, false);
+    assert!(!dir_meta.is_file());
+    assert!(dir_meta.is_dir());
+    assert!(!dir_meta.is_symlink());
+
+    let symlink_meta = FileMetadata::new(false, false, true);
+    assert!(!symlink_meta.is_file());
+    assert!(!symlink_meta.is_dir());
+    assert!(symlink_meta.is_symlink());
+}

src/tests/alias.rs

@@ -299,3 +299,20 @@ fn alias_try_fragment_as_path() {
     let resolution = resolver.resolve(&f, "#/a").map(|r| r.full_path());
     assert_eq!(resolution, Ok(f.join("#").join("a.js")));
 }
+
+#[test]
+fn alias_with_multiple_fallbacks() {
+    let f = super::fixture();
+    let resolver = Resolver::new(ResolveOptions {
+        alias: vec![(
+            "multi".to_string(),
+            vec![
+                AliasValue::Path(f.join("nonexistent").to_string_lossy().to_string()),
+                AliasValue::Path(f.join("foo").to_string_lossy().to_string()),
+            ],
+        )],
+        ..ResolveOptions::default()
+    });
+    let resolution = resolver.resolve(&f, "multi/index.js").map(|r| r.full_path());
+    assert_eq!(resolution, Ok(f.join("foo/index.js")));
+}

src/tests/extensions.rs

@@ -126,3 +126,24 @@ fn without_leading_dot() {
         ..ResolveOptions::default()
     });
 }
+
+#[test]
+fn extension_combinations() {
+    let f = super::fixture().join("extensions");
+
+    let resolver = Resolver::new(ResolveOptions {
+        extensions: vec![".jsx".into(), ".tsx".into(), ".js".into(), ".ts".into()],
+        ..ResolveOptions::default()
+    });
+
+    let pass = [
+        ("should resolve file with explicit extension", "./foo.ts", "foo.ts"),
+        ("should resolve directory index", "./dir/index.ts", "dir/index.ts"),
+    ];
+
+    for (comment, request, expected_path) in pass {
+        let resolved_path = resolver.resolve(&f, request).map(|r| r.full_path());
+        let expected = f.join(expected_path);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {request} {expected_path}");
+    }
+}

src/tests/package_json.rs

@@ -46,3 +46,19 @@ fn adjacent_to_node_modules() {
     assert_eq!(package_json_path, Some(&resolved_package_json_path));
     assert_eq!(package_json_name, Some("misc"));
 }
+
+#[test]
+fn package_json_with_symlinks_true() {
+    use crate::ResolveOptions;
+
+    let f = super::fixture_root().join("misc");
+    let resolver = Resolver::new(ResolveOptions { symlinks: true, ..ResolveOptions::default() });
+
+    let path = f.join("dir-with-index");
+    let request = "./index.js";
+    let resolved_package_json_path = f.join("package.json");
+
+    let package_json = resolver.resolve(&path, request).unwrap().package_json().cloned();
+    let package_json_path = package_json.as_ref().map(|p| &p.path);
+    assert_eq!(package_json_path, Some(&resolved_package_json_path));
+}

src/tests/resolve.rs

@@ -138,6 +138,20 @@ fn prefer_file_over_dir() {
     }
 }
 
+#[test]
+fn resolve_edge_cases() {
+    let f = super::fixture();
+    let resolver = Resolver::default();
+
+    // Test various edge cases for path resolution
+    let data = [("resolve with multiple dots", f.clone(), "./a/../main1.js", f.join("main1.js"))];
+
+    for (comment, path, request, expected) in data {
+        let resolved_path = resolver.resolve(&path, request).map(|r| r.full_path());
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
+    }
+}
+
 #[test]
 fn resolve_dot() {
     let f = super::fixture_root().join("dot");

src/tests/symlink.rs

@@ -200,3 +200,36 @@ fn test_unsupported_targets() {
         Err(ResolveError::PathNotSupported(dos_device_temp_path))
     );
 }
+
+#[test]
+fn test_circular_symlink() {
+    let Some(SymlinkFixturePaths { root: _, temp_path }) =
+        prepare_symlinks("temp.test_circular_symlink").unwrap()
+    else {
+        return;
+    };
+
+    // Create a circular symlink: link1 -> link2 -> link1
+    let link1_path = temp_path.join("link1");
+    let link2_path = temp_path.join("link2");
+
+    if symlink(&link2_path, &link1_path, FileType::File).is_err() {
+        // Skip test if we can't create symlinks
+        return;
+    }
+    if symlink(&link1_path, &link2_path, FileType::File).is_err() {
+        // Skip test if we can't create symlinks
+        _ = fs::remove_file(&link1_path);
+        return;
+    }
+
+    let resolver = Resolver::default();
+    let result = resolver.resolve(&temp_path, "./link1");
+
+    // Should error due to circular symlink
+    assert!(result.is_err());
+
+    // Cleanup
+    _ = fs::remove_file(&link1_path);
+    _ = fs::remove_file(&link2_path);
+}

src/tests/tsconfig_extends.rs

@@ -95,6 +95,24 @@ fn test_extend_tsconfig_template_variables() {
     assert_eq!(resolved_path, Ok(f.join("src/utils.ts")));
 }
 
+#[test]
+fn test_extend_tsconfig_missing_file() {
+    use crate::ResolveError;
+
+    let f = super::fixture_root().join("tsconfig/cases");
+
+    let resolver = Resolver::new(ResolveOptions {
+        tsconfig: Some(TsconfigOptions {
+            config_file: f.join("nonexistent-tsconfig.json"),
+            references: TsconfigReferences::Auto,
+        }),
+        ..ResolveOptions::default()
+    });
+
+    let result = resolver.resolve_tsconfig(&f);
+    assert!(matches!(result, Err(ResolveError::TsconfigNotFound(_))));
+}
+
 #[test]
 fn test_extend_tsconfig_multiple_inheritance() {
     let f = super::fixture_root().join("tsconfig/cases/extends-chain");