Add additional tests for uri module

This expands the test coverage for the uri module covering
all mutants that currently exist.

This will likely become the narrowest scope of my mutant ci coverage
so that we can start with full coverage and expand the scope out as
we catch more mutants.

Author: benalleng

payjoin-test-utils/src/lib.rs

@@ -253,7 +253,7 @@ pub async fn wait_for_service_ready(
 }
 
 pub static EXAMPLE_URL: Lazy<Url> =
-    Lazy::new(|| Url::parse("https://relay.com").expect("invalid URL"));
+    Lazy::new(|| Url::parse("https://example.com").expect("invalid URL"));
 
 pub const KEY_ID: KeyId = 1;
 pub const KEM: Kem = Kem::K256Sha256;

payjoin/src/uri/mod.rs

@@ -207,6 +207,8 @@ impl bitcoin_uri::de::DeserializationState<'_> for DeserializationState {
 mod tests {
     use std::convert::TryFrom;
 
+    use bitcoin_uri::SerializeParams;
+
     use super::*;
 
     #[test]
@@ -269,10 +271,48 @@ mod tests {
 
     #[test]
     fn test_unsupported() {
-        assert!(!Uri::try_from("bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX")
+        assert!(
+            !Uri::try_from("bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX")
+                .unwrap()
+                .extras
+                .pj_is_supported(),
+            "Uri expected a failure with missing pj extras, but it succeeded"
+        );
+    }
+
+    #[test]
+    fn test_supported() {
+        assert!(
+            Uri::try_from(
+                "bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX?amount=0.01\
+                   &pjos=0&pj=HTTPS://EXAMPLE.COM/\
+                   %23OH1QYPM5JXYNS754Y4R45QWE336QFX6ZR8DQGVQCULVZTV20TFVEYDMFQC"
+            )
             .unwrap()
             .extras
-            .pj_is_supported());
+            .pj_is_supported(),
+            "Uri expected a success with a well formatted pj extras, but it failed"
+        );
+    }
+
+    #[test]
+    fn test_pj_param_unknown() {
+        use bitcoin_uri::de::DeserializationState as _;
+        let uri = "bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX?pjos=1&pj=HTTPS://EXAMPLE.COM/\
+                   %23OH1QYPM5JXYNS754Y4R45QWE336QFX6ZR8DQGVQCULVZTV20TFVEYDMFQC";
+        let pjuri = Uri::try_from(uri).unwrap().assume_checked().check_pj_supported().unwrap();
+        let serialized_params = pjuri.extras.serialize_params();
+        let pjos_key = serialized_params.clone().next().expect("Missing pjos key").0;
+        let pj_key = serialized_params.clone().next().expect("Missing pj key").0;
+
+        let state = DeserializationState::default();
+
+        assert!(state.is_param_known(pjos_key), "The pjos key should match 'pjos', but it failed");
+        assert!(state.is_param_known(pj_key), "The pj key should match 'pj', but it failed");
+        assert!(
+            !state.is_param_known("unknown_param"),
+            "An unknown_param should not match 'pj' or 'pjos'"
+        );
     }
 
     #[test]

payjoin/src/uri/url_ext.rs

@@ -225,26 +225,29 @@ impl std::error::Error for ParseReceiverPubkeyParamError {
 
 #[cfg(test)]
 mod tests {
-    use payjoin_test_utils::BoxError;
+    use payjoin_test_utils::{BoxError, EXAMPLE_URL};
 
     use super::*;
     use crate::{Uri, UriExt};
 
     #[test]
     fn test_ohttp_get_set() {
-        let mut url = Url::parse("https://example.com").unwrap();
+        let mut url = EXAMPLE_URL.clone();
 
         let serialized = "OH1QYPM5JXYNS754Y4R45QWE336QFX6ZR8DQGVQCULVZTV20TFVEYDMFQC";
         let ohttp_keys = OhttpKeys::from_str(serialized).unwrap();
         url.set_ohttp(ohttp_keys.clone());
 
         assert_eq!(url.fragment(), Some(serialized));
-        assert_eq!(url.ohttp().unwrap(), ohttp_keys);
+        assert_eq!(
+            url.ohttp().expect("Ohttp keys have been set but are missing on get"),
+            ohttp_keys
+        );
     }
 
     #[test]
     fn test_errors_when_parsing_ohttp() {
-        let missing_ohttp_url = Url::parse("https://example.com").unwrap();
+        let missing_ohttp_url = EXAMPLE_URL.clone();
         assert!(matches!(
             missing_ohttp_url.ohttp(),
             Err(ParseOhttpKeysParamError::MissingOhttpKeys)
@@ -261,19 +264,19 @@ mod tests {
 
     #[test]
     fn test_exp_get_set() {
-        let mut url = Url::parse("https://example.com").unwrap();
+        let mut url = EXAMPLE_URL.clone();
 
         let exp_time =
             std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(1720547781);
         url.set_exp(exp_time);
         assert_eq!(url.fragment(), Some("EX1C4UC6ES"));
 
-        assert_eq!(url.exp().unwrap(), exp_time);
+        assert_eq!(url.exp().expect("Expiry has been set but is missing on get"), exp_time);
     }
 
     #[test]
     fn test_errors_when_parsing_exp() {
-        let missing_exp_url = Url::parse("http://example.com").unwrap();
+        let missing_exp_url = EXAMPLE_URL.clone();
         assert!(matches!(missing_exp_url.exp(), Err(ParseExpParamError::MissingExp)));
 
         let invalid_bech32_exp_url =
@@ -290,7 +293,41 @@ mod tests {
         // Not enough data to decode into a u32
         let invalid_timestamp_exp_url =
             Url::parse("http://example.com?pj=https://test-payjoin-url#EX10").unwrap();
-        assert!(matches!(invalid_timestamp_exp_url.exp(), Err(ParseExpParamError::InvalidExp(_))))
+        assert!(matches!(invalid_timestamp_exp_url.exp(), Err(ParseExpParamError::InvalidExp(_))));
+    }
+
+    #[test]
+    fn test_errors_when_parsing_receiver_pubkey() {
+        let missing_receiver_pubkey_url = EXAMPLE_URL.clone();
+        assert!(matches!(
+            missing_receiver_pubkey_url.receiver_pubkey(),
+            Err(ParseReceiverPubkeyParamError::MissingPubkey)
+        ));
+
+        let invalid_bech32_receiver_pubkey_url =
+            Url::parse("http://example.com?pj=https://test-payjoin-url#RK1invalid_bech_32")
+                .unwrap();
+        assert!(matches!(
+            invalid_bech32_receiver_pubkey_url.receiver_pubkey(),
+            Err(ParseReceiverPubkeyParamError::DecodeBech32(_))
+        ));
+
+        // Since the HRP is everything to the left of the right-most separator, the invalid url in
+        // this test would have it's HRP being parsed as RK101 instead of the expected RK1
+        let invalid_hrp_receiver_pubkey_url =
+            Url::parse("http://example.com?pj=https://test-payjoin-url#RK101").unwrap();
+        assert!(matches!(
+            invalid_hrp_receiver_pubkey_url.receiver_pubkey(),
+            Err(ParseReceiverPubkeyParamError::InvalidHrp(_))
+        ));
+
+        // Not enough data to decode into a u32
+        let invalid_receiver_pubkey_url =
+            Url::parse("http://example.com?pj=https://test-payjoin-url#RK10").unwrap();
+        assert!(matches!(
+            invalid_receiver_pubkey_url.receiver_pubkey(),
+            Err(ParseReceiverPubkeyParamError::InvalidPubkey(_))
+        ));
     }
 
     #[test]