refactor(resolver): check against Result for better assertion message (#573)

crates/oxc_resolver/tests/enhanced_resolve/test/alias.rs

@@ -1,14 +1,16 @@
 //! <https://github.com/webpack/enhanced-resolve/blob/main/test/alias.test.js>
 
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
-use oxc_resolver::{AliasValue, ResolveError, ResolveOptions, Resolver, ResolverGeneric};
+use oxc_resolver::{
+    AliasValue, Resolution, ResolveError, ResolveOptions, Resolver, ResolverGeneric,
+};
 
 use crate::MemoryFS;
 
 #[test]
 #[cfg(not(target_os = "windows"))] // MemoryFS's path separator is always `/` so the test will not pass in windows.
-fn alias() -> Result<(), ResolveError> {
+fn alias() {
     let f = Path::new("/");
 
     let file_system = MemoryFS::new(&[
@@ -85,8 +87,8 @@ fn alias() -> Result<(), ResolveError> {
     ];
 
     for (comment, request, expected) in pass {
-        let resolution = resolver.resolve(f, request)?;
-        assert_eq!(resolution.full_path(), Path::new(expected), "{comment} {request}");
+        let resolved_path = resolver.resolve(f, request).map(Resolution::full_path);
+        assert_eq!(resolved_path, Ok(PathBuf::from(expected)), "{comment} {request}");
     }
 
     #[rustfmt::skip]
@@ -98,8 +100,6 @@ fn alias() -> Result<(), ResolveError> {
         let resolution = resolver.resolve(f, request);
         assert_eq!(resolution, Err(expected), "{comment} {request}");
     }
-
-    Ok(())
 }
 
 #[test]

crates/oxc_resolver/tests/enhanced_resolve/test/browser_field.rs

@@ -2,7 +2,7 @@
 
 use std::path::PathBuf;
 
-use oxc_resolver::{ResolveError, ResolveOptions, Resolver};
+use oxc_resolver::{Resolution, ResolveError, ResolveOptions, Resolver};
 
 fn fixture() -> PathBuf {
     super::fixture().join("browser-module")
@@ -12,12 +12,10 @@ fn fixture() -> PathBuf {
 fn ignore() {
     let f = fixture();
 
-    let options = ResolveOptions {
+    let resolver = Resolver::new(ResolveOptions {
         alias_fields: vec!["browser".into(), "innerBrowser1".into(), "innerBrowser2".into()],
         ..ResolveOptions::default()
-    };
-
-    let resolver = Resolver::new(options);
+    });
 
     #[rustfmt::skip]
     let data = [
@@ -35,13 +33,13 @@ fn ignore() {
 }
 
 #[test]
-fn replace_file() -> Result<(), ResolveError> {
+fn replace_file() {
     let f = fixture();
 
-    let options =
-        ResolveOptions { alias_fields: vec!["browser".into()], ..ResolveOptions::default() };
-
-    let resolver = Resolver::new(options);
+    let resolver = Resolver::new(ResolveOptions {
+        alias_fields: vec!["browser".into()],
+        ..ResolveOptions::default()
+    });
 
     #[rustfmt::skip]
     let data = [
@@ -61,10 +59,7 @@ fn replace_file() -> Result<(), ResolveError> {
     ];
 
     for (comment, path, request, expected) in data {
-        let resolution = resolver.resolve(&path, request)?;
-        let resolved_path = resolution.path();
-        assert_eq!(resolved_path, expected, "{comment} {path:?} {request}");
+        let resolved_path = resolver.resolve(&path, request).map(Resolution::full_path);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
     }
-
-    Ok(())
 }

crates/oxc_resolver/tests/enhanced_resolve/test/extension_alias.rs

@@ -2,14 +2,14 @@
 
 use std::path::PathBuf;
 
-use oxc_resolver::{ResolveError, ResolveOptions, Resolver};
+use oxc_resolver::{Resolution, ResolveError, ResolveOptions, Resolver};
 
 fn fixture() -> PathBuf {
     super::fixture().join("extension-alias")
 }
 
 #[test]
-fn extension_alias() -> Result<(), ResolveError> {
+fn extension_alias() {
     let f = fixture();
 
     let resolver = Resolver::new(ResolveOptions {
@@ -31,9 +31,8 @@ fn extension_alias() -> Result<(), ResolveError> {
     ];
 
     for (comment, path, request, expected) in pass {
-        let resolution = resolver.resolve(&path, request)?;
-        let resolved_path = resolution.path();
-        assert_eq!(resolved_path, expected, "{comment} {path:?} {request}");
+        let resolved_path = resolver.resolve(&path, request).map(Resolution::full_path);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
     }
 
     #[rustfmt::skip]
@@ -45,12 +44,10 @@ fn extension_alias() -> Result<(), ResolveError> {
         let resolution = resolver.resolve(&path, request);
         assert_eq!(resolution, Err(ResolveError::ExtensionAlias), "{comment} {path:?} {request}");
     }
-
-    Ok(())
 }
 
 #[test]
-fn not_apply_to_extension_nor_main_files() -> Result<(), ResolveError> {
+fn not_apply_to_extension_nor_main_files() {
     // should not apply extension alias to extensions or mainFiles field
     let options = ResolveOptions {
         extensions: vec![".js".into()],
@@ -63,15 +60,13 @@ fn not_apply_to_extension_nor_main_files() -> Result<(), ResolveError> {
 
     #[rustfmt::skip]
     let pass = [
-        ("directory", f.clone(), "./dir2", f.join("dir2/index.js")),
-        ("file", f.clone(), "./dir2/index", f.join("dir2/index.js")),
+        ("directory", f.clone(), "./dir2", "dir2/index.js"),
+        ("file", f.clone(), "./dir2/index", "dir2/index.js"),
     ];
 
     for (comment, path, request, expected) in pass {
-        let resolution = resolver.resolve(&path, request)?;
-        let resolved_path = resolution.path();
-        assert_eq!(resolved_path, expected, "{comment} {path:?} {request}");
+        let resolved_path = resolver.resolve(&path, request).map(Resolution::full_path);
+        let expected = f.join(expected);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
     }
-
-    Ok(())
 }

crates/oxc_resolver/tests/enhanced_resolve/test/extensions.rs

@@ -9,7 +9,7 @@ fn fixture() -> PathBuf {
 }
 
 #[test]
-fn extensions() -> Result<(), ResolveError> {
+fn extensions() {
     let f = fixture();
 
     let resolver = Resolver::new(ResolveOptions {
@@ -27,10 +27,9 @@ fn extensions() -> Result<(), ResolveError> {
     ];
 
     for (comment, request, expected_path) in pass {
-        let resolution = resolver.resolve(&f, request)?;
-        let path = resolution.path().canonicalize().unwrap();
-        let expected = f.join(expected_path).canonicalize().unwrap();
-        assert_eq!(path, expected, "{comment} {request} {expected_path}");
+        let resolved_path = resolver.resolve(&f, request).map(Resolution::full_path);
+        let expected = f.join(expected_path);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {request} {expected_path}");
     }
 
     #[rustfmt::skip]
@@ -43,8 +42,6 @@ fn extensions() -> Result<(), ResolveError> {
         let error = ResolveError::NotFound(expected_error.into_boxed_path());
         assert_eq!(resolution, Err(error), "{comment} {request} {resolution:?}");
     }
-
-    Ok(())
 }
 
 #[test]

crates/oxc_resolver/tests/enhanced_resolve/test/fallback.rs

@@ -1,14 +1,14 @@
 //! https://github.com/webpack/enhanced-resolve/blob/main/test/fallback.test.js
 
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
-use oxc_resolver::{AliasValue, ResolveError, ResolveOptions, ResolverGeneric};
+use oxc_resolver::{AliasValue, Resolution, ResolveError, ResolveOptions, ResolverGeneric};
 
 use crate::MemoryFS;
 
 #[test]
 #[cfg(not(target_os = "windows"))] // MemoryFS's path separator is always `/` so the test will not pass in windows.
-fn fallback() -> Result<(), ResolveError> {
+fn fallback() {
     let f = Path::new("/");
 
     let file_system = MemoryFS::new(&[
@@ -74,8 +74,8 @@ fn fallback() -> Result<(), ResolveError> {
     ];
 
     for (comment, request, expected) in pass {
-        let resolution = resolver.resolve(f, request)?;
-        assert_eq!(resolution.full_path(), Path::new(expected), "{comment} {request}");
+        let resolved_path = resolver.resolve(f, request).map(Resolution::full_path);
+        assert_eq!(resolved_path, Ok(PathBuf::from(expected)), "{comment} {request}");
     }
 
     #[rustfmt::skip]
@@ -87,6 +87,4 @@ fn fallback() -> Result<(), ResolveError> {
         let resolution = resolver.resolve(f, request);
         assert_eq!(resolution, Err(expected), "{comment} {request}");
     }
-
-    Ok(())
 }

crates/oxc_resolver/tests/enhanced_resolve/test/resolve.rs

@@ -1,9 +1,9 @@
 //! <https://github.com/webpack/enhanced-resolve/blob/main/test/resolve.test.js>
 
-use oxc_resolver::{ResolveError, Resolver};
+use oxc_resolver::{Resolution, Resolver};
 
 #[test]
-fn resolve() -> Result<(), ResolveError> {
+fn resolve() {
     let f = super::fixture();
 
     let resolver = Resolver::default();
@@ -43,11 +43,9 @@ fn resolve() -> Result<(), ResolveError> {
     ];
 
     for (comment, path, request, expected) in data {
-        let resolution = resolver.resolve(&path, request)?;
-        assert_eq!(resolution.full_path(), expected, "{comment} {path:?} {request}");
+        let resolved_path = resolver.resolve(&path, request).map(Resolution::full_path);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
     }
-
-    Ok(())
 }
 
 #[test]
@@ -60,7 +58,7 @@ fn prefer_relative_resolve() {}
 
 #[test]
 #[ignore = "add resolveToContext option"]
-fn resolve_context() -> Result<(), ResolveError> {
+fn resolve_context() {
     let f = super::fixture();
     let resolver = Resolver::default();
 
@@ -73,10 +71,7 @@ fn resolve_context() -> Result<(), ResolveError> {
     ];
 
     for (comment, path, request, expected) in data {
-        let resolution = resolver.resolve(&path, request)?;
-        let resolved_path = resolution.path();
-        assert_eq!(resolved_path, expected, "{comment} {path:?} {request}");
+        let resolved_path = resolver.resolve(&path, request).map(Resolution::full_path);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
     }
-
-    Ok(())
 }

crates/oxc_resolver/tests/enhanced_resolve/test/scoped_packages.rs

@@ -2,14 +2,14 @@
 
 use std::path::PathBuf;
 
-use oxc_resolver::{ResolveError, ResolveOptions, Resolver};
+use oxc_resolver::{Resolution, ResolveOptions, Resolver};
 
 fn fixture() -> PathBuf {
     super::fixture().join("scoped")
 }
 
 #[test]
-fn scoped_packages() -> Result<(), ResolveError> {
+fn scoped_packages() {
     let f = fixture();
 
     let resolver = Resolver::new(ResolveOptions {
@@ -25,10 +25,7 @@ fn scoped_packages() -> Result<(), ResolveError> {
     ];
 
     for (comment, path, request, expected) in pass {
-        let resolution = resolver.resolve(&f, request)?;
-        let resolved_path = resolution.path();
-        assert_eq!(resolved_path, expected, "{comment} {path:?} {request}");
+        let resolved_path = resolver.resolve(&f, request).map(Resolution::full_path);
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
     }
-
-    Ok(())
 }

crates/oxc_resolver/tests/enhanced_resolve/test/simple.rs

@@ -2,10 +2,10 @@
 
 use std::env;
 
-use oxc_resolver::{ResolveError, Resolver};
+use oxc_resolver::Resolver;
 
 #[test]
-fn simple() -> Result<(), ResolveError> {
+fn simple() {
     // mimic `enhanced-resolve/test/simple.test.js`
     let f = env::current_dir().unwrap().join("tests/enhanced_resolve/test/");
 
@@ -18,11 +18,9 @@ fn simple() -> Result<(), ResolveError> {
     ];
 
     for (comment, path, request) in data {
-        let resolution = resolver.resolve(&path, request)?;
-        let resolved_path = resolution.path().canonicalize().unwrap();
+        let resolved_path =
+            resolver.resolve(&path, request).map(|f| f.full_path().canonicalize().unwrap());
         let expected = f.join("../lib/index.js").canonicalize().unwrap();
-        assert_eq!(resolved_path, expected, "{comment} {path:?} {request}");
+        assert_eq!(resolved_path, Ok(expected), "{comment} {path:?} {request}");
     }
-
-    Ok(())
 }