> From for FileType {
}
/// Helper function to check if a path is likely a URL.
-
fn is_url(path: &Path) -> bool {
path.to_str()
.and_then(|s| Url::parse(s).ok())
diff --git a/lychee-lib/src/utils/path.rs b/lychee-lib/src/utils/path.rs
index bb4847ed9a..daa4f7fde6 100644
--- a/lychee-lib/src/utils/path.rs
+++ b/lychee-lib/src/utils/path.rs
@@ -1,4 +1,4 @@
-use crate::{Base, ErrorKind, Result};
+use crate::{ErrorKind, Result};
use cached::proc_macro::cached;
use once_cell::sync::Lazy;
use path_clean::PathClean;
@@ -9,11 +9,6 @@ use std::path::{Path, PathBuf};
static CURRENT_DIR: Lazy =
Lazy::new(|| env::current_dir().expect("cannot get current dir from environment"));
-/// Returns the base if it is a valid `PathBuf`
-fn get_base_dir(base: &Option) -> Option {
- base.as_ref().and_then(Base::dir)
-}
-
/// Create an absolute path out of a `PathBuf`.
///
/// The `clean` method is relatively expensive
@@ -29,55 +24,33 @@ pub(crate) fn absolute_path(path: PathBuf) -> PathBuf {
.clean()
}
-/// Get the directory name of a given `Path`.
-fn dirname(src: &'_ Path) -> Option<&'_ Path> {
- if src.is_file() {
- return src.parent();
- }
- Some(src)
-}
-
/// Resolve `dst` that was linked to from within `src`
///
/// Returns Ok(None) in case of an absolute local link without a `base_url`
-pub(crate) fn resolve(src: &Path, dst: &Path, base: &Option) -> Result> {
+pub(crate) fn resolve(
+ src: &Path,
+ dst: &PathBuf,
+ ignore_absolute_local_links: bool,
+) -> Result> {
let resolved = match dst {
relative if dst.is_relative() => {
// Find `dst` in the parent directory of `src`
let Some(parent) = src.parent() else {
- return Err(ErrorKind::InvalidFile(relative.to_path_buf()));
+ return Err(ErrorKind::InvalidFile(relative.clone()));
};
parent.join(relative)
}
absolute if dst.is_absolute() => {
- // Absolute local links (leading slash) require the `base_url` to
- // define the document root. Silently ignore the link in case the
- // `base_url` is not defined.
- let Some(base) = get_base_dir(base) else {
+ if ignore_absolute_local_links {
return Ok(None);
- };
- let Some(dir) = dirname(&base) else {
- return Err(ErrorKind::InvalidBase(
- base.display().to_string(),
- "The given directory cannot be a base".to_string(),
- ));
- };
- join(dir.to_path_buf(), absolute)
+ }
+ PathBuf::from(absolute)
}
- _ => return Err(ErrorKind::InvalidFile(dst.to_path_buf())),
+ _ => return Err(ErrorKind::InvalidFile(dst.clone())),
};
Ok(Some(absolute_path(resolved)))
}
-/// A cumbersome way to concatenate paths without checking their
-/// existence on disk. See
-fn join(base: PathBuf, dst: &Path) -> PathBuf {
- let mut abs = base.into_os_string();
- let target_str = dst.as_os_str();
- abs.push(target_str);
- PathBuf::from(abs)
-}
-
/// Check if `child` is a subdirectory/file inside `parent`
///
/// Note that `contains(parent, parent)` will return `true`
@@ -110,7 +83,7 @@ mod test_path {
let dummy = PathBuf::from("index.html");
let abs_path = PathBuf::from("./foo.html");
assert_eq!(
- resolve(&dummy, &abs_path, &None)?,
+ resolve(&dummy, &abs_path, true)?,
Some(env::current_dir().unwrap().join("foo.html"))
);
Ok(())
@@ -123,7 +96,7 @@ mod test_path {
let dummy = PathBuf::from("./index.html");
let abs_path = PathBuf::from("./foo.html");
assert_eq!(
- resolve(&dummy, &abs_path, &None)?,
+ resolve(&dummy, &abs_path, true)?,
Some(env::current_dir().unwrap().join("foo.html"))
);
Ok(())
@@ -136,43 +109,12 @@ mod test_path {
let abs_index = PathBuf::from("/path/to/index.html");
let abs_path = PathBuf::from("./foo.html");
assert_eq!(
- resolve(&abs_index, &abs_path, &None)?,
+ resolve(&abs_index, &abs_path, true)?,
Some(PathBuf::from("/path/to/foo.html"))
);
Ok(())
}
- // dummy
- // foo.html
- // valid base dir
- #[test]
- fn test_resolve_absolute_from_base_dir() -> Result<()> {
- let dummy = PathBuf::new();
- let abs_path = PathBuf::from("/foo.html");
- let base = Some(Base::Local(PathBuf::from("/some/absolute/base/dir")));
- assert_eq!(
- resolve(&dummy, &abs_path, &base)?,
- Some(PathBuf::from("/some/absolute/base/dir/foo.html"))
- );
- Ok(())
- }
-
- // /path/to/index.html
- // /other/path/to/foo.html
- #[test]
- fn test_resolve_absolute_from_absolute() -> Result<()> {
- let abs_index = PathBuf::from("/path/to/index.html");
- let abs_path = PathBuf::from("/other/path/to/foo.html");
- let base = Some(Base::Local(PathBuf::from("/some/absolute/base/dir")));
- assert_eq!(
- resolve(&abs_index, &abs_path, &base)?,
- Some(PathBuf::from(
- "/some/absolute/base/dir/other/path/to/foo.html"
- ))
- );
- Ok(())
- }
-
#[test]
fn test_contains() {
let parent_dir = tempfile::tempdir().unwrap();
diff --git a/lychee-lib/src/utils/request.rs b/lychee-lib/src/utils/request.rs
index 7867e50f09..ca66f7d857 100644
--- a/lychee-lib/src/utils/request.rs
+++ b/lychee-lib/src/utils/request.rs
@@ -8,14 +8,14 @@ use std::{
use crate::{
basic_auth::BasicAuthExtractor,
- types::{uri::raw::RawUri, InputContent, InputSource},
+ types::{uri::raw::RawUri, InputSource},
utils::{path, url},
Base, BasicAuthCredentials, ErrorKind, Request, Result, Uri,
};
/// Extract basic auth credentials for a given URL.
fn extract_credentials(
- extractor: &Option,
+ extractor: Option<&BasicAuthExtractor>,
uri: &Uri,
) -> Option {
extractor.as_ref().and_then(|ext| ext.matches(uri))
@@ -25,10 +25,11 @@ fn extract_credentials(
fn create_request(
raw_uri: &RawUri,
source: &InputSource,
- base: &Option,
- extractor: &Option,
+ root_dir: Option<&PathBuf>,
+ base: Option<&Base>,
+ extractor: Option<&BasicAuthExtractor>,
) -> Result {
- let uri = try_parse_into_uri(raw_uri, source, base)?;
+ let uri = try_parse_into_uri(raw_uri, source, root_dir, base)?;
let source = truncate_source(source);
let element = raw_uri.element.clone();
let attribute = raw_uri.attribute.clone();
@@ -48,8 +49,13 @@ fn create_request(
/// to create a valid URI.
/// - If a URI cannot be created from the file path.
/// - If the source is not a file path (i.e. the URI type is not supported).
-fn try_parse_into_uri(raw_uri: &RawUri, source: &InputSource, base: &Option) -> Result {
- let text = raw_uri.text.clone();
+fn try_parse_into_uri(
+ raw_uri: &RawUri,
+ source: &InputSource,
+ root_dir: Option<&PathBuf>,
+ base: Option<&Base>,
+) -> Result {
+ let text = prepend_root_dir_if_absolute_local_link(&raw_uri.text, root_dir);
let uri = match Uri::try_from(raw_uri.clone()) {
Ok(uri) => uri,
Err(_) => match base {
@@ -58,7 +64,9 @@ fn try_parse_into_uri(raw_uri: &RawUri, source: &InputSource, base: &Option return Err(ErrorKind::InvalidBaseJoin(text.clone())),
},
None => match source {
- InputSource::FsPath(root) => create_uri_from_file_path(root, &text, base)?,
+ InputSource::FsPath(root) => {
+ create_uri_from_file_path(root, &text, root_dir.is_none())?
+ }
_ => return Err(ErrorKind::UnsupportedUriType(text)),
},
},
@@ -81,7 +89,7 @@ pub(crate) fn is_anchor(text: &str) -> bool {
fn create_uri_from_file_path(
file_path: &Path,
link_text: &str,
- base: &Option,
+ ignore_absolute_local_links: bool,
) -> Result {
let target_path = if is_anchor(link_text) {
// For anchors, we need to append the anchor to the file name.
@@ -94,7 +102,9 @@ fn create_uri_from_file_path(
} else {
link_text.to_string()
};
- let Ok(constructed_url) = resolve_and_create_url(file_path, &target_path, base) else {
+ let Ok(constructed_url) =
+ resolve_and_create_url(file_path, &target_path, ignore_absolute_local_links)
+ else {
return Err(ErrorKind::InvalidPathToUri(target_path));
};
Ok(Uri {
@@ -125,17 +135,16 @@ fn truncate_source(source: &InputSource) -> InputSource {
/// it will not be added to the `HashSet`.
pub(crate) fn create(
uris: Vec,
- input_content: &InputContent,
- base: &Option,
- extractor: &Option,
+ source: &InputSource,
+ root_dir: Option<&PathBuf>,
+ base: Option<&Base>,
+ extractor: Option<&BasicAuthExtractor>,
) -> HashSet {
- let base = base
- .clone()
- .or_else(|| Base::from_source(&input_content.source));
+ let base = base.cloned().or_else(|| Base::from_source(source));
uris.into_iter()
.filter_map(|raw_uri| {
- match create_request(&raw_uri, &input_content.source, &base, extractor) {
+ match create_request(&raw_uri, source, root_dir, base.as_ref(), extractor) {
Ok(request) => Some(request),
Err(e) => {
warn!("Error creating request: {:?}", e);
@@ -160,7 +169,7 @@ pub(crate) fn create(
fn resolve_and_create_url(
src_path: &Path,
dest_path: &str,
- base_uri: &Option,
+ ignore_absolute_local_links: bool,
) -> Result {
let (dest_path, fragment) = url::remove_get_params_and_separate_fragment(dest_path);
@@ -168,8 +177,11 @@ fn resolve_and_create_url(
// This addresses the issue mentioned in the original comment about double-encoding
let decoded_dest = percent_decode_str(dest_path).decode_utf8()?;
- let Ok(Some(resolved_path)) = path::resolve(src_path, &PathBuf::from(&*decoded_dest), base_uri)
- else {
+ let Ok(Some(resolved_path)) = path::resolve(
+ src_path,
+ &PathBuf::from(&*decoded_dest),
+ ignore_absolute_local_links,
+ ) else {
return Err(ErrorKind::InvalidPathToUri(decoded_dest.to_string()));
};
@@ -181,10 +193,20 @@ fn resolve_and_create_url(
Ok(url)
}
+fn prepend_root_dir_if_absolute_local_link(text: &str, root_dir: Option<&PathBuf>) -> String {
+ if text.starts_with('/') {
+ if let Some(path) = root_dir {
+ if let Some(path_str) = path.to_str() {
+ return format!("{path_str}{text}");
+ }
+ }
+ }
+ text.to_string()
+}
+
#[cfg(test)]
mod tests {
use super::*;
- use crate::types::FileType;
#[test]
fn test_is_anchor() {
@@ -195,28 +217,17 @@ mod tests {
#[test]
fn test_create_uri_from_path() {
let result =
- resolve_and_create_url(&PathBuf::from("/README.md"), "test+encoding", &None).unwrap();
+ resolve_and_create_url(&PathBuf::from("/README.md"), "test+encoding", true).unwrap();
assert_eq!(result.as_str(), "file:///test+encoding");
}
- fn create_input(content: &str, file_type: FileType) -> InputContent {
- InputContent {
- content: content.to_string(),
- file_type,
- source: InputSource::String(content.to_string()),
- }
- }
-
#[test]
fn test_relative_url_resolution() {
- let base = Some(Base::try_from("https://example.com/path/page.html").unwrap());
- let input = create_input(
- r#"Relative Link"#,
- FileType::Html,
- );
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::String(String::new());
let uris = vec![RawUri::from("relative.html")];
- let requests = create(uris, &input, &base, &None);
+ let requests = create(uris, &source, None, Some(&base), None);
assert_eq!(requests.len(), 1);
assert!(requests
@@ -226,14 +237,11 @@ mod tests {
#[test]
fn test_absolute_url_resolution() {
- let base = Some(Base::try_from("https://example.com/path/page.html").unwrap());
- let input = create_input(
- r#"Absolute Link"#,
- FileType::Html,
- );
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::String(String::new());
let uris = vec![RawUri::from("https://another.com/page")];
- let requests = create(uris, &input, &base, &None);
+ let requests = create(uris, &source, None, Some(&base), None);
assert_eq!(requests.len(), 1);
assert!(requests
@@ -243,14 +251,11 @@ mod tests {
#[test]
fn test_root_relative_url_resolution() {
- let base = Some(Base::try_from("https://example.com/path/page.html").unwrap());
- let input = create_input(
- r#"Root Relative Link"#,
- FileType::Html,
- );
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::String(String::new());
let uris = vec![RawUri::from("/root-relative")];
- let requests = create(uris, &input, &base, &None);
+ let requests = create(uris, &source, None, Some(&base), None);
assert_eq!(requests.len(), 1);
assert!(requests
@@ -260,14 +265,11 @@ mod tests {
#[test]
fn test_parent_directory_url_resolution() {
- let base = Some(Base::try_from("https://example.com/path/page.html").unwrap());
- let input = create_input(
- r#"Parent Directory Link"#,
- FileType::Html,
- );
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::String(String::new());
let uris = vec![RawUri::from("../parent")];
- let requests = create(uris, &input, &base, &None);
+ let requests = create(uris, &source, None, Some(&base), None);
assert_eq!(requests.len(), 1);
assert!(requests
@@ -277,11 +279,156 @@ mod tests {
#[test]
fn test_fragment_url_resolution() {
- let base = Some(Base::try_from("https://example.com/path/page.html").unwrap());
- let input = create_input(r##"Fragment Link"##, FileType::Html);
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::String(String::new());
let uris = vec![RawUri::from("#fragment")];
- let requests = create(uris, &input, &base, &None);
+ let requests = create(uris, &source, None, Some(&base), None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "https://example.com/path/page.html#fragment"));
+ }
+
+ #[test]
+ fn test_relative_url_resolution_from_root_dir() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("relative.html")];
+ let requests = create(uris, &source, Some(&root_dir), None, None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "file:///some/relative.html"));
+ }
+
+ #[test]
+ fn test_absolute_url_resolution_from_root_dir() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("https://another.com/page")];
+ let requests = create(uris, &source, Some(&root_dir), None, None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "https://another.com/page"));
+ }
+
+ #[test]
+ fn test_root_relative_url_resolution_from_root_dir() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("/root-relative")];
+ let requests = create(uris, &source, Some(&root_dir), None, None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "file:///tmp/lychee/root-relative"));
+ }
+
+ #[test]
+ fn test_parent_directory_url_resolution_from_root_dir() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("../parent")];
+ let requests = create(uris, &source, Some(&root_dir), None, None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "file:///parent"));
+ }
+
+ #[test]
+ fn test_fragment_url_resolution_from_root_dir() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("#fragment")];
+ let requests = create(uris, &source, Some(&root_dir), None, None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "file:///some/page.html#fragment"));
+ }
+
+ #[test]
+ fn test_relative_url_resolution_from_root_dir_and_base_url() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("relative.html")];
+ let requests = create(uris, &source, Some(&root_dir), Some(&base), None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "https://example.com/path/relative.html"));
+ }
+
+ #[test]
+ fn test_absolute_url_resolution_from_root_dir_and_base_url() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("https://another.com/page")];
+ let requests = create(uris, &source, Some(&root_dir), Some(&base), None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "https://another.com/page"));
+ }
+
+ #[test]
+ fn test_root_relative_url_resolution_from_root_dir_and_base_url() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("/root-relative")];
+ let requests = create(uris, &source, Some(&root_dir), Some(&base), None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "https://example.com/tmp/lychee/root-relative"));
+ }
+
+ #[test]
+ fn test_parent_directory_url_resolution_from_root_dir_and_base_url() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("../parent")];
+ let requests = create(uris, &source, Some(&root_dir), Some(&base), None);
+
+ assert_eq!(requests.len(), 1);
+ assert!(requests
+ .iter()
+ .any(|r| r.uri.url.as_str() == "https://example.com/parent"));
+ }
+
+ #[test]
+ fn test_fragment_url_resolution_from_root_dir_and_base_url() {
+ let root_dir = PathBuf::from("/tmp/lychee");
+ let base = Base::try_from("https://example.com/path/page.html").unwrap();
+ let source = InputSource::FsPath(PathBuf::from("/some/page.html"));
+
+ let uris = vec![RawUri::from("#fragment")];
+ let requests = create(uris, &source, Some(&root_dir), Some(&base), None);
assert_eq!(requests.len(), 1);
assert!(requests
@@ -291,14 +438,10 @@ mod tests {
#[test]
fn test_no_base_url_resolution() {
- let base = None;
- let input = create_input(
- r#"Absolute Link"#,
- FileType::Html,
- );
+ let source = InputSource::String(String::new());
let uris = vec![RawUri::from("https://example.com/page")];
- let requests = create(uris, &input, &base, &None);
+ let requests = create(uris, &source, None, None, None);
assert_eq!(requests.len(), 1);
assert!(requests
@@ -308,11 +451,17 @@ mod tests {
#[test]
fn test_create_request_from_relative_file_path() {
- let base = Some(Base::Local(PathBuf::from("/tmp/lychee")));
+ let base = Base::Local(PathBuf::from("/tmp/lychee"));
let input_source = InputSource::FsPath(PathBuf::from("page.html"));
- let actual =
- create_request(&RawUri::from("file.html"), &input_source, &base, &None).unwrap();
+ let actual = create_request(
+ &RawUri::from("file.html"),
+ &input_source,
+ None,
+ Some(&base),
+ None,
+ )
+ .unwrap();
assert_eq!(
actual,
@@ -330,15 +479,16 @@ mod tests {
#[test]
fn test_create_request_from_absolute_file_path() {
- let base = Some(Base::Local(PathBuf::from("/tmp/lychee")));
+ let base = Base::Local(PathBuf::from("/tmp/lychee"));
let input_source = InputSource::FsPath(PathBuf::from("/tmp/lychee/page.html"));
// Use an absolute path that's outside the base directory
let actual = create_request(
&RawUri::from("/usr/local/share/doc/example.html"),
&input_source,
- &base,
- &None,
+ None,
+ Some(&base),
+ None,
)
.unwrap();
@@ -358,29 +508,53 @@ mod tests {
#[test]
fn test_parse_relative_path_into_uri() {
- let base = Some(Base::Local(PathBuf::from("/tmp/lychee")));
- let input = create_input(
- r#"Relative Link"#,
- FileType::Html,
- );
+ let base = Base::Local(PathBuf::from("/tmp/lychee"));
+ let source = InputSource::String(String::new());
let raw_uri = RawUri::from("relative.html");
- let uri = try_parse_into_uri(&raw_uri, &input.source, &base).unwrap();
+ let uri = try_parse_into_uri(&raw_uri, &source, None, Some(&base)).unwrap();
assert_eq!(uri.url.as_str(), "file:///tmp/lychee/relative.html");
}
#[test]
fn test_parse_absolute_path_into_uri() {
- let base = Some(Base::Local(PathBuf::from("/tmp/lychee")));
- let input = create_input(
- r#"Absolute Link"#,
- FileType::Html,
- );
+ let base = Base::Local(PathBuf::from("/tmp/lychee"));
+ let source = InputSource::String(String::new());
let raw_uri = RawUri::from("absolute.html");
- let uri = try_parse_into_uri(&raw_uri, &input.source, &base).unwrap();
+ let uri = try_parse_into_uri(&raw_uri, &source, None, Some(&base)).unwrap();
assert_eq!(uri.url.as_str(), "file:///tmp/lychee/absolute.html");
}
+
+ #[test]
+ fn test_prepend_with_absolute_local_link_and_root_dir() {
+ let text = "/absolute/path";
+ let root_dir = PathBuf::from("/root");
+ let result = prepend_root_dir_if_absolute_local_link(text, Some(&root_dir));
+ assert_eq!(result, "/root/absolute/path");
+ }
+
+ #[test]
+ fn test_prepend_with_absolute_local_link_and_no_root_dir() {
+ let text = "/absolute/path";
+ let result = prepend_root_dir_if_absolute_local_link(text, None);
+ assert_eq!(result, "/absolute/path");
+ }
+
+ #[test]
+ fn test_prepend_with_relative_link_and_root_dir() {
+ let text = "relative/path";
+ let root_dir = PathBuf::from("/root");
+ let result = prepend_root_dir_if_absolute_local_link(text, Some(&root_dir));
+ assert_eq!(result, "relative/path");
+ }
+
+ #[test]
+ fn test_prepend_with_relative_link_and_no_root_dir() {
+ let text = "relative/path";
+ let result = prepend_root_dir_if_absolute_local_link(text, None);
+ assert_eq!(result, "relative/path");
+ }
}