feat: removed unwrap from v2 of send and recieve (#544)

part of #487 

Removed `unwrap()` from send and recieve test of v2

Author: spacebear21

payjoin/src/receive/v2/mod.rs

@@ -575,67 +575,68 @@ mod test {
     use ohttp::hpke::{Aead, Kdf, Kem};
     use ohttp::{KeyId, SymmetricSuite};
     use once_cell::sync::Lazy;
+    use payjoin_test_utils::BoxError;
 
     use super::*;
 
     const KEY_ID: KeyId = 1;
     const KEM: Kem = Kem::K256Sha256;
     const SYMMETRIC: &[SymmetricSuite] =
         &[ohttp::SymmetricSuite::new(Kdf::HkdfSha256, Aead::ChaCha20Poly1305)];
-    static EXAMPLE_DIRECTORY_URL: Lazy<Url> =
-        Lazy::new(|| Url::parse("https://directory.com").unwrap());
 
-    static EXAMPLE_OHTTP_RELAY: Lazy<Url> = Lazy::new(|| Url::parse("https://relay.com").unwrap());
+    static EXAMPLE_URL: Lazy<Url> =
+        Lazy::new(|| Url::parse("https://relay.com").expect("invalid URL"));
 
     static SHARED_CONTEXT: Lazy<SessionContext> = Lazy::new(|| SessionContext {
         address: Address::from_str("tb1q6d3a2w975yny0asuvd9a67ner4nks58ff0q8g4")
-            .unwrap()
+            .expect("valid address")
             .assume_checked(),
-        directory: EXAMPLE_DIRECTORY_URL.clone(),
+        directory: EXAMPLE_URL.clone(),
         subdirectory: None,
-        ohttp_keys: OhttpKeys(ohttp::KeyConfig::new(KEY_ID, KEM, Vec::from(SYMMETRIC)).unwrap()),
+        ohttp_keys: OhttpKeys(
+            ohttp::KeyConfig::new(KEY_ID, KEM, Vec::from(SYMMETRIC)).expect("valid key config"),
+        ),
         expiry: SystemTime::now() + Duration::from_secs(60),
         s: HpkeKeyPair::gen_keypair(),
         e: None,
     });
 
     #[test]
-    fn extract_err_req() -> Result<(), Box<dyn std::error::Error>> {
+    fn extract_err_req() -> Result<(), BoxError> {
         let mut proposal = UncheckedProposal {
-            v1: crate::receive::v1::test::proposal_from_test_vector().unwrap(),
+            v1: crate::receive::v1::test::proposal_from_test_vector()?,
             context: SHARED_CONTEXT.clone(),
         };
 
         let server_error = proposal
             .clone()
             .check_broadcast_suitability(None, |_| Err("mock error".into()))
             .err()
-            .unwrap();
+            .ok_or("expected error but got success")?;
         assert_eq!(
             server_error.to_json(),
             r#"{ "errorCode": "unavailable", "message": "Receiver error" }"#
         );
-        let (_req, _ctx) =
-            proposal.clone().extract_err_req(&server_error, EXAMPLE_OHTTP_RELAY.to_owned())?;
+        let (_req, _ctx) = proposal.clone().extract_err_req(&server_error, &*EXAMPLE_URL)?;
 
         let internal_error = InternalPayloadError::MissingPayment.into();
-        let (_req, _ctx) =
-            proposal.extract_err_req(&internal_error, EXAMPLE_OHTTP_RELAY.to_owned())?;
+        let (_req, _ctx) = proposal.extract_err_req(&internal_error, &*EXAMPLE_URL)?;
         Ok(())
     }
 
     #[test]
-    fn receiver_ser_de_roundtrip() {
+    fn receiver_ser_de_roundtrip() -> Result<(), serde_json::Error> {
         let session = Receiver { context: SHARED_CONTEXT.clone() };
-        let serialized = serde_json::to_string(&session).unwrap();
-        let deserialized: Receiver = serde_json::from_str(&serialized).unwrap();
+        let serialized = serde_json::to_string(&session)?;
+        let deserialized: Receiver = serde_json::from_str(&serialized)?;
         assert_eq!(session, deserialized);
+        Ok(())
     }
 
     #[test]
     fn test_v2_pj_uri() {
         let uri = Receiver { context: SHARED_CONTEXT.clone() }.pj_uri();
-        assert_ne!(uri.extras.endpoint, EXAMPLE_DIRECTORY_URL.clone());
+        assert_ne!(uri.extras.endpoint, EXAMPLE_URL.clone());
         assert!(!uri.extras.disable_output_substitution);
     }
 }

payjoin/src/send/v2/mod.rs

@@ -200,8 +200,10 @@ fn serialize_v2_body(
     min_fee_rate: FeeRate,
 ) -> Result<Vec<u8>, CreateRequestError> {
     // Grug say localhost base be discarded anyway. no big brain needed.
+    let base_url = Url::parse("http://localhost").expect("invalid URL");
+
     let placeholder_url = serialize_url(
-        Url::parse("http://localhost").expect("localhost is a valid URL"),
+        base_url,
         disable_output_substitution,
         fee_contribution,
         min_fee_rate,
@@ -325,22 +327,26 @@ impl HpkeContext {
 #[cfg(test)]
 mod test {
     #[test]
-    fn req_ctx_ser_de_roundtrip() {
+    fn req_ctx_ser_de_roundtrip() -> Result<(), payjoin_test_utils::BoxError> {
         use super::*;
         use crate::send::test::ORIGINAL_PSBT;
+
+        let psbt = Psbt::from_str(ORIGINAL_PSBT)?;
+        let endpoint = Url::parse("http://localhost:1234")?;
         let req_ctx = Sender {
             v1: v1::Sender {
-                psbt: Psbt::from_str(ORIGINAL_PSBT).unwrap(),
-                endpoint: Url::parse("http://localhost:1234").unwrap(),
+                psbt,
+                endpoint,
                 disable_output_substitution: false,
                 fee_contribution: None,
                 min_fee_rate: FeeRate::ZERO,
                 payee: ScriptBuf::from(vec![0x00]),
             },
             reply_key: HpkeKeyPair::gen_keypair().0,
         };
-        let serialized = serde_json::to_string(&req_ctx).unwrap();
-        let deserialized = serde_json::from_str(&serialized).unwrap();
+        let serialized = serde_json::to_string(&req_ctx)?;
+        let deserialized = serde_json::from_str(&serialized)?;
         assert!(req_ctx == deserialized);
+        Ok(())
     }
 }