lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README | LICENSE

relay_url.rs (4482B)

      1 use radroots_local_events::{RelayUrlValidationError, normalize_relay_url, normalize_relay_urls};
      2 
      3 #[test]
      4 fn relay_url_error_display_is_stable() {
      5     assert_eq!(
      6         RelayUrlValidationError::Empty.to_string(),
      7         "relay url must not be empty"
      8     );
      9     assert_eq!(
     10         RelayUrlValidationError::UnsupportedScheme("https://relay.example".to_owned()).to_string(),
     11         "relay url must use ws or wss, got `https://relay.example`"
     12     );
     13     assert_eq!(
     14         RelayUrlValidationError::MissingHost("wss://".to_owned()).to_string(),
     15         "relay url must include a host, got `wss://`"
     16     );
     17     assert_eq!(
     18         RelayUrlValidationError::InvalidAuthority("wss://user@relay.example".to_owned())
     19             .to_string(),
     20         "relay url authority is invalid, got `wss://user@relay.example`"
     21     );
     22     assert_eq!(
     23         RelayUrlValidationError::InvalidPort("wss://relay.example:abc".to_owned()).to_string(),
     24         "relay url port is invalid, got `wss://relay.example:abc`"
     25     );
     26 }
     27 
     28 #[test]
     29 fn relay_url_normalization_trims_and_dedupes() {
     30     let relays = normalize_relay_urls([
     31         " wss://relay-a.example ",
     32         "wss://relay-a.example",
     33         "ws://127.0.0.1:8080/nostr",
     34     ])
     35     .expect("normalize relays");
     36 
     37     assert_eq!(
     38         relays,
     39         vec![
     40             "wss://relay-a.example".to_owned(),
     41             "ws://127.0.0.1:8080/nostr".to_owned()
     42         ]
     43     );
     44 }
     45 
     46 #[test]
     47 fn relay_url_validation_rejects_empty_values() {
     48     assert_eq!(
     49         normalize_relay_url("   "),
     50         Err(RelayUrlValidationError::Empty)
     51     );
     52 }
     53 
     54 #[test]
     55 fn relay_url_validation_rejects_non_websocket_schemes() {
     56     assert_eq!(
     57         normalize_relay_url("https://relay.example"),
     58         Err(RelayUrlValidationError::UnsupportedScheme(
     59             "https://relay.example".to_owned()
     60         ))
     61     );
     62 }
     63 
     64 #[test]
     65 fn relay_url_validation_rejects_hostless_values() {
     66     assert_eq!(
     67         normalize_relay_url("wss://"),
     68         Err(RelayUrlValidationError::MissingHost("wss://".to_owned()))
     69     );
     70     assert_eq!(
     71         normalize_relay_url("wss:///relay"),
     72         Err(RelayUrlValidationError::MissingHost(
     73             "wss:///relay".to_owned()
     74         ))
     75     );
     76     assert_eq!(
     77         normalize_relay_url("ws://:8080"),
     78         Err(RelayUrlValidationError::MissingHost(
     79             "ws://:8080".to_owned()
     80         ))
     81     );
     82 }
     83 
     84 #[test]
     85 fn relay_url_validation_rejects_malformed_authority() {
     86     assert_eq!(
     87         normalize_relay_url("wss://user@relay.example"),
     88         Err(RelayUrlValidationError::InvalidAuthority(
     89             "wss://user@relay.example".to_owned()
     90         ))
     91     );
     92     assert_eq!(
     93         normalize_relay_url("wss://relay example"),
     94         Err(RelayUrlValidationError::InvalidAuthority(
     95             "wss://relay example".to_owned()
     96         ))
     97     );
     98     assert_eq!(
     99         normalize_relay_url("wss://2001:db8::1"),
    100         Err(RelayUrlValidationError::InvalidAuthority(
    101             "wss://2001:db8::1".to_owned()
    102         ))
    103     );
    104     assert_eq!(
    105         normalize_relay_url("wss://[2001:db8::1"),
    106         Err(RelayUrlValidationError::InvalidAuthority(
    107             "wss://[2001:db8::1".to_owned()
    108         ))
    109     );
    110     assert_eq!(
    111         normalize_relay_url("wss://[]"),
    112         Err(RelayUrlValidationError::MissingHost("wss://[]".to_owned()))
    113     );
    114     assert_eq!(
    115         normalize_relay_url("wss://[2001:db8::1]extra"),
    116         Err(RelayUrlValidationError::InvalidAuthority(
    117             "wss://[2001:db8::1]extra".to_owned()
    118         ))
    119     );
    120 }
    121 
    122 #[test]
    123 fn relay_url_validation_rejects_invalid_ports() {
    124     assert_eq!(
    125         normalize_relay_url("wss://relay.example:"),
    126         Err(RelayUrlValidationError::InvalidPort(
    127             "wss://relay.example:".to_owned()
    128         ))
    129     );
    130     assert_eq!(
    131         normalize_relay_url("wss://relay.example:abc"),
    132         Err(RelayUrlValidationError::InvalidPort(
    133             "wss://relay.example:abc".to_owned()
    134         ))
    135     );
    136     assert_eq!(
    137         normalize_relay_url("wss://[2001:db8::1]:abc"),
    138         Err(RelayUrlValidationError::InvalidPort(
    139             "wss://[2001:db8::1]:abc".to_owned()
    140         ))
    141     );
    142 }
    143 
    144 #[test]
    145 fn relay_url_validation_accepts_bracketed_ipv6() {
    146     assert_eq!(
    147         normalize_relay_url("wss://[2001:db8::1]:8080/nostr").expect("ipv6 relay"),
    148         "wss://[2001:db8::1]:8080/nostr"
    149     );
    150     assert_eq!(
    151         normalize_relay_url("wss://[2001:db8::1]").expect("ipv6 relay without port"),
    152         "wss://[2001:db8::1]"
    153     );
    154 }