test(gateway): cover public-base-url normalization, base_url, allowed_hosts

Adds unit tests for the public-gateway-base-url plumbing this PR introduces:
- normalize_public_base_url: accepts an https origin (trailing slash trimmed),
  treats blank as None, and rejects non-https, embedded credentials, query /
  fragment, non-root paths, and unparseable input.
- advertised_base_url / GatewayConfig::base_url: fall back to http://localhost
  when no public URL is set, otherwise advertise the trimmed origin.
- GatewayConfig::allowed_hosts: always include loopback, add the public host
  (and host:port when present), and ignore an invalid public URL without panic.

Signed-off-by: Mohammod Al Amin Ashik <maa.ashik00@gmail.com>

Author: its-mash

apps/desktop/src-tauri/src/commands/gateway.rs

@@ -1925,3 +1925,50 @@ pub struct PoolStatsResponse {
     pub connected_instances: usize,
     pub total_space_server_mappings: usize,
 }
+
+#[cfg(test)]
+mod public_base_url_tests {
+    use super::{advertised_base_url, normalize_public_base_url};
+
+    #[test]
+    fn normalize_accepts_https_origin_and_trims_trailing_slash() {
+        assert_eq!(
+            normalize_public_base_url("https://mcp.example.com/").unwrap(),
+            Some("https://mcp.example.com".to_string())
+        );
+        assert_eq!(
+            normalize_public_base_url("https://mcp.example.com:8443").unwrap(),
+            Some("https://mcp.example.com:8443".to_string())
+        );
+    }
+
+    #[test]
+    fn normalize_treats_blank_as_none() {
+        assert_eq!(normalize_public_base_url("").unwrap(), None);
+        assert_eq!(normalize_public_base_url("   ").unwrap(), None);
+    }
+
+    #[test]
+    fn normalize_rejects_unsafe_or_non_origin_urls() {
+        // Non-https, credentials, query/fragment, non-root path, and garbage all rejected.
+        assert!(normalize_public_base_url("http://mcp.example.com").is_err());
+        assert!(normalize_public_base_url("https://user:pass@mcp.example.com").is_err());
+        assert!(normalize_public_base_url("https://mcp.example.com/?x=1").is_err());
+        assert!(normalize_public_base_url("https://mcp.example.com/#frag").is_err());
+        assert!(normalize_public_base_url("https://mcp.example.com/mcp").is_err());
+        assert!(normalize_public_base_url("not a url").is_err());
+    }
+
+    #[test]
+    fn advertised_base_url_falls_back_to_localhost() {
+        assert_eq!(advertised_base_url(None, 45818), "http://localhost:45818");
+        assert_eq!(
+            advertised_base_url(Some("   "), 45818),
+            "http://localhost:45818"
+        );
+        assert_eq!(
+            advertised_base_url(Some("https://mcp.example.com/"), 45818),
+            "https://mcp.example.com"
+        );
+    }
+}

crates/mcpmux-gateway/src/server/mod.rs

@@ -623,3 +623,60 @@ impl GatewayServerHandle {
         self.shutdown.is_some()
     }
 }
+
+#[cfg(test)]
+mod config_tests {
+    use super::*;
+
+    fn config_with(public: Option<&str>) -> GatewayConfig {
+        GatewayConfig {
+            public_base_url: public.map(str::to_string),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn base_url_defaults_to_localhost() {
+        let cfg = config_with(None);
+        assert_eq!(cfg.base_url(), format!("http://localhost:{}", cfg.port));
+    }
+
+    #[test]
+    fn base_url_uses_public_origin_and_trims_trailing_slash() {
+        assert_eq!(
+            config_with(Some("https://mcp.example.com/")).base_url(),
+            "https://mcp.example.com"
+        );
+    }
+
+    #[test]
+    fn allowed_hosts_always_include_loopback() {
+        let hosts = config_with(None).allowed_hosts();
+        for h in ["localhost", "127.0.0.1", "::1"] {
+            assert!(hosts.contains(&h.to_string()), "missing {h} in {hosts:?}");
+        }
+    }
+
+    #[test]
+    fn allowed_hosts_include_public_host_and_optional_port() {
+        let hosts = config_with(Some("https://mcp.example.com")).allowed_hosts();
+        assert!(hosts.contains(&"mcp.example.com".to_string()), "{hosts:?}");
+
+        let hosts_port = config_with(Some("https://mcp.example.com:8443")).allowed_hosts();
+        assert!(
+            hosts_port.contains(&"mcp.example.com".to_string()),
+            "{hosts_port:?}"
+        );
+        assert!(
+            hosts_port.contains(&"mcp.example.com:8443".to_string()),
+            "{hosts_port:?}"
+        );
+    }
+
+    #[test]
+    fn allowed_hosts_ignores_invalid_public_url_without_panicking() {
+        let hosts = config_with(Some("not a url")).allowed_hosts();
+        assert!(hosts.contains(&"localhost".to_string()));
+        assert!(!hosts.iter().any(|h| h.contains("not a url")));
+    }
+}