Add more tests for better explicit coverage of important features

Author: Byron

gix-url/tests/url/access.rs

@@ -54,6 +54,48 @@ fn password() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn mutation_roundtrip() -> crate::Result {
+    let mut url = gix_url::parse("https://user@host/path".into())?;
+    url.set_user(Some("newuser".into()));
+    url.set_password(Some("secret".into()));
+
+    let serialized = url.to_bstring();
+    let reparsed = gix_url::parse(serialized.as_ref())?;
+
+    assert_eq!(url, reparsed);
+    assert_eq!(reparsed.user(), Some("newuser"));
+    assert_eq!(reparsed.password(), Some("secret"));
+
+    Ok(())
+}
+
+#[test]
+fn from_bytes_roundtrip() -> crate::Result {
+    let original = "https://user:password@example.com:8080/path/to/repo";
+    let url = gix_url::parse(original.into())?;
+
+    let bytes = url.to_bstring();
+    let from_bytes = gix_url::Url::from_bytes(bytes.as_ref())?;
+
+    assert_eq!(url, from_bytes);
+    assert_eq!(from_bytes.to_bstring(), bytes);
+
+    Ok(())
+}
+
+#[test]
+fn from_bytes_with_non_utf8_path() -> crate::Result {
+    let url = gix_url::parse(b"/path/to\xff/repo".as_slice().into())?;
+    let bytes = url.to_bstring();
+    let from_bytes = gix_url::Url::from_bytes(bytes.as_ref())?;
+
+    assert_eq!(url, from_bytes);
+    assert_eq!(from_bytes.path, url.path);
+
+    Ok(())
+}
+
 #[test]
 fn user_argument_safety() -> crate::Result {
     let url = gix_url::parse("ssh://-Fconfigfile@foo/bar".into())?;

gix-url/tests/url/parse/file.rs

@@ -215,4 +215,28 @@ mod unix {
             url(Scheme::File, None, "x:", None, b"/path/to/git"),
         )
     }
+
+    #[test]
+    fn file_url_with_ipv6_and_user() -> crate::Result {
+        assert_url_roundtrip(
+            "file://User@[::1]/repo",
+            gix_url::Url::from_parts(
+                Scheme::File,
+                Some("User".into()),
+                None,
+                Some("[::1]".into()),
+                None,
+                b"/repo".into(),
+                false,
+            )?,
+        )
+    }
+
+    #[test]
+    fn file_url_with_ipv6() -> crate::Result {
+        assert_url_roundtrip(
+            "file://[::1]/repo",
+            url(Scheme::File, None, "[::1]", None, b"/repo"),
+        )
+    }
 }

gix-url/tests/url/parse/http.rs

@@ -94,3 +94,35 @@ fn http_missing_path() -> crate::Result {
     assert_url("http://host.xz", url(Scheme::Http, None, "host.xz", None, b"/"))?;
     Ok(())
 }
+
+#[test]
+fn http_with_ipv6() -> crate::Result {
+    assert_url_roundtrip("http://[::1]/repo", url(Scheme::Http, None, "[::1]", None, b"/repo"))
+}
+
+#[test]
+fn http_with_ipv6_and_port() -> crate::Result {
+    assert_url_roundtrip("http://[::1]:8080/repo", url(Scheme::Http, None, "[::1]", 8080, b"/repo"))
+}
+
+#[test]
+fn https_with_ipv6_user_and_port() -> crate::Result {
+    assert_url_roundtrip(
+        "https://user@[2001:db8::1]:8443/repo",
+        url(Scheme::Https, "user", "[2001:db8::1]", 8443, b"/repo"),
+    )
+}
+
+#[test]
+fn percent_encoded_path() -> crate::Result {
+    let url = gix_url::parse("https://example.com/path/with%20spaces/file".into())?;
+    assert_eq!(url.path, "/path/with%20spaces/file", "paths are not decoded");
+    Ok(())
+}
+
+#[test]
+fn percent_encoded_international_path() -> crate::Result {
+    let url = gix_url::parse("https://example.com/caf%C3%A9".into())?;
+    assert_eq!(url.path, "/caf%C3%A9", "international characters remain encoded in path");
+    Ok(())
+}

gix-url/tests/url/parse/invalid.rs

@@ -39,3 +39,21 @@ fn file_missing_host_path_separator() {
 fn missing_port_despite_indication() {
     assert_matches!(parse("ssh://host.xz:"), Err(MissingRepositoryPath { .. }));
 }
+
+#[test]
+fn port_zero_is_invalid() {
+    assert_matches!(parse("ssh://host.xz:0/path"), Err(Url { .. }));
+}
+
+#[test]
+fn port_too_large() {
+    assert_matches!(parse("ssh://host.xz:65536/path"), Err(Url { .. }));
+    assert_matches!(parse("ssh://host.xz:99999/path"), Err(Url { .. }));
+}
+
+#[test]
+fn invalid_port_format() {
+    let url = parse("ssh://host.xz:abc/path").expect("non-numeric port is treated as part of host");
+    assert_eq!(url.host(), Some("host.xz:abc"), "port parse failure makes it part of hostname");
+    assert_eq!(url.port, None);
+}

gix-url/tests/url/parse/mod.rs

@@ -107,6 +107,24 @@ mod radicle {
 
 mod http;
 
+mod ports {
+    use crate::parse::{assert_url_roundtrip, url};
+    use gix_url::Scheme;
+
+    #[test]
+    fn max_valid_port() -> crate::Result {
+        assert_url_roundtrip(
+            "ssh://host.xz:65535/repo",
+            url(Scheme::Ssh, None, "host.xz", 65535, b"/repo"),
+        )
+    }
+
+    #[test]
+    fn port_one() -> crate::Result {
+        assert_url_roundtrip("ssh://host.xz:1/repo", url(Scheme::Ssh, None, "host.xz", 1, b"/repo"))
+    }
+}
+
 mod git {
     use gix_url::Scheme;
 
@@ -119,6 +137,21 @@ mod git {
             url(Scheme::Git, None, "example.com", None, b"~byron/hello"),
         )
     }
+
+    #[test]
+    fn default_port_is_9418() -> crate::Result {
+        let url = url(Scheme::Git, None, "example.com", None, b"/repo");
+        assert_eq!(url.port_or_default(), Some(9418));
+        Ok(())
+    }
+
+    #[test]
+    fn git_with_explicit_port() -> crate::Result {
+        assert_url_roundtrip(
+            "git://example.com:1234/repo",
+            url(Scheme::Git, None, "example.com", 1234, b"/repo"),
+        )
+    }
 }
 
 mod unknown {

gix-url/tests/url/parse/ssh.rs

@@ -233,3 +233,59 @@ fn bad_alternative_form_with_port() -> crate::Result {
     assert_eq!(url, "ssh://host.xz:21/");
     Ok(())
 }
+
+#[test]
+fn ipv6_address_without_port() -> crate::Result {
+    let url = assert_url("ssh://[::1]/repo", url(Scheme::Ssh, None, "::1", None, b"/repo"))?;
+    assert_eq!(url.host(), Some("::1"), "brackets are stripped for SSH");
+    Ok(())
+}
+
+#[test]
+fn ipv6_address_with_port() -> crate::Result {
+    let url = assert_url("ssh://[::1]:22/repo", url(Scheme::Ssh, None, "::1", 22, b"/repo"))?;
+    assert_eq!(url.host(), Some("::1"));
+    assert_eq!(url.port, Some(22));
+    Ok(())
+}
+
+#[test]
+fn ipv6_address_with_user() -> crate::Result {
+    let url = assert_url("ssh://user@[::1]/repo", url(Scheme::Ssh, "user", "::1", None, b"/repo"))?;
+    assert_eq!(url.host(), Some("::1"));
+    assert_eq!(url.user(), Some("user"));
+    Ok(())
+}
+
+#[test]
+fn ipv6_address_with_user_and_port() -> crate::Result {
+    let url = assert_url("ssh://user@[::1]:22/repo", url(Scheme::Ssh, "user", "::1", 22, b"/repo"))?;
+    assert_eq!(url.host(), Some("::1"));
+    assert_eq!(url.user(), Some("user"));
+    assert_eq!(url.port, Some(22));
+    Ok(())
+}
+
+#[test]
+fn ipv6_full_address() -> crate::Result {
+    let url = assert_url("ssh://[2001:db8::1]/repo", url(Scheme::Ssh, None, "2001:db8::1", None, b"/repo"))?;
+    assert_eq!(url.host(), Some("2001:db8::1"));
+    Ok(())
+}
+
+#[test]
+fn ipv6_address_scp_like() -> crate::Result {
+    let url = assert_url("[::1]:repo", url_alternate(Scheme::Ssh, None, "::1", None, b"repo"))?;
+    assert_eq!(url.host(), Some("::1"), "SCP-like format with IPv6");
+    Ok(())
+}
+
+#[test]
+fn ipv6_address_scp_like_with_user() -> crate::Result {
+    let result = gix_url::parse("user@[::1]:repo".into());
+    assert!(
+        result.is_err(),
+        "SCP-like format with brackets is not supported - Git doesn't support this either"
+    );
+    Ok(())
+}