Extend tests for rest of receive module (payjoin#632)

Author: DanGould

.cargo/mutants.toml

@@ -1,5 +1,5 @@
 additional_cargo_args = ["--all-features"]
-examine_globs = ["payjoin/src/uri/*.rs", "payjoin/src/receive/v1/**/*.rs"]
+examine_globs = ["payjoin/src/uri/*.rs", "payjoin/src/receive/**/*.rs"]
 exclude_globs = []
 exclude_re = [
 	"impl Debug",

payjoin-cli/Cargo.toml

@@ -43,7 +43,7 @@ reqwest = { version = "0.12", default-features = false }
 rustls = { version = "0.22.4", optional = true }
 serde = { version = "1.0.160", features = ["derive"] }
 sled = "0.34"
-tokio = { version = "1.12.0", features = ["full"] }
+tokio = { version = "1.38.1", features = ["full"] }
 tokio-rustls = { version = "0.25", features = ["ring"], default-features = false, optional = true }
 url = { version = "2.3.1", features = ["serde"] }
 

payjoin-test-utils/Cargo.toml

@@ -24,7 +24,7 @@ rustls = "0.22"
 reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
 testcontainers = "0.15.0"
 testcontainers-modules = { version = "0.3.7", features = ["redis"] }
-tokio = { version = "1.12.0", features = ["full"] }
+tokio = { version = "1.38.1", features = ["full"] }
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 url = "2.2.2"

payjoin/Cargo.toml

@@ -45,7 +45,7 @@ serde_json = { version = "1.0.108", optional = true }
 bitcoind = { version = "0.36.0", features = ["0_21_2"] }
 payjoin-test-utils = { path = "../payjoin-test-utils" }
 once_cell = "1"
-tokio = { version = "1.12.0", features = ["full"] }
+tokio = { version = "1.38.1", features = ["full"] }
 tracing = "0.1.40"
 
 [package.metadata.docs.rs]

payjoin/src/receive/multiparty/mod.rs

@@ -248,3 +248,64 @@ impl FinalizedProposal {
 
     pub fn v2(&self) -> &[v2::UncheckedProposal] { &self.v2_proposals }
 }
+
+#[cfg(test)]
+mod test {
+
+    use std::any::{Any, TypeId};
+
+    use payjoin_test_utils::{BoxError, PARSED_ORIGINAL_PSBT};
+
+    use super::{v1, v2, FinalizedProposal, UncheckedProposalBuilder, SUPPORTED_VERSIONS};
+    use crate::receive::optional_parameters::Params;
+    use crate::receive::v2::test::SHARED_CONTEXT;
+
+    fn multiparty_proposal_from_test_vector() -> v1::UncheckedProposal {
+        let pairs = url::form_urlencoded::parse("v=2&optimisticmerge=true".as_bytes());
+        let params = Params::from_query_pairs(pairs, SUPPORTED_VERSIONS)
+            .expect("Could not parse from query pairs");
+        v1::UncheckedProposal { psbt: PARSED_ORIGINAL_PSBT.clone(), params }
+    }
+
+    #[test]
+    fn test_build_multiparty() -> Result<(), BoxError> {
+        let proposal_one = v2::UncheckedProposal {
+            v1: multiparty_proposal_from_test_vector(),
+            context: SHARED_CONTEXT.clone(),
+        };
+        let proposal_two = v2::UncheckedProposal {
+            v1: multiparty_proposal_from_test_vector(),
+            context: SHARED_CONTEXT.clone(),
+        };
+        let mut multiparty = UncheckedProposalBuilder::new();
+        multiparty.add(proposal_one)?;
+        multiparty.add(proposal_two)?;
+        let unchecked_proposal = multiparty.build();
+        assert!(unchecked_proposal?.contexts.len() == 2);
+        Ok(())
+    }
+
+    #[test]
+    fn finalize_multiparty() -> Result<(), BoxError> {
+        use crate::psbt::PsbtExt;
+        let proposal_one = v2::UncheckedProposal {
+            v1: multiparty_proposal_from_test_vector(),
+            context: SHARED_CONTEXT.clone(),
+        };
+        let proposal_two = v2::UncheckedProposal {
+            v1: multiparty_proposal_from_test_vector(),
+            context: SHARED_CONTEXT.clone(),
+        };
+        let mut finalized_multiparty = FinalizedProposal::new();
+        finalized_multiparty.add(proposal_one.clone())?;
+        assert_eq!(finalized_multiparty.v2()[0].type_id(), TypeId::of::<v2::UncheckedProposal>());
+
+        finalized_multiparty.add(proposal_two)?;
+        assert_eq!(finalized_multiparty.v2()[1].type_id(), TypeId::of::<v2::UncheckedProposal>());
+
+        let multiparty_psbt =
+            finalized_multiparty.combine().expect("could not create PSBT from finalized proposal");
+        assert!(multiparty_psbt.validate_input_utxos().is_ok());
+        Ok(())
+    }
+}

payjoin/src/receive/optional_parameters.rs

@@ -133,3 +133,25 @@ impl fmt::Display for Error {
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
+
+#[cfg(test)]
+pub(crate) mod test {
+    use bitcoin::Amount;
+
+    use super::*;
+
+    #[test]
+    fn test_parse_params() {
+        use bitcoin::FeeRate;
+
+        let pairs = url::form_urlencoded::parse(b"maxadditionalfeecontribution=182&additionalfeeoutputindex=0&minfeerate=1&disableoutputsubstitution=true&optimisticmerge=true");
+        let params =
+            Params::from_query_pairs(pairs, &[1]).expect("Could not parse params from query pairs");
+        assert_eq!(params.v, 1);
+        assert_eq!(params.output_substitution, OutputSubstitution::Disabled);
+        assert_eq!(params.additional_fee_contribution, Some((Amount::from_sat(182), 0)));
+        assert_eq!(params.min_fee_rate, FeeRate::BROADCAST_MIN);
+        #[cfg(feature = "_multiparty")]
+        assert!(params.optimistic_merge)
+    }
+}

payjoin/src/receive/v2/mod.rs

@@ -655,15 +655,16 @@ fn id(s: &HpkeKeyPair) -> ShortId {
 }
 
 #[cfg(test)]
-mod test {
+pub mod test {
     use std::str::FromStr;
 
     use once_cell::sync::Lazy;
     use payjoin_test_utils::{BoxError, EXAMPLE_URL, KEM, KEY_ID, SYMMETRIC};
+    use persist::Value;
 
     use super::*;
 
-    static SHARED_CONTEXT: Lazy<SessionContext> = Lazy::new(|| SessionContext {
+    pub(crate) static SHARED_CONTEXT: Lazy<SessionContext> = Lazy::new(|| SessionContext {
         address: Address::from_str("tb1q6d3a2w975yny0asuvd9a67ner4nks58ff0q8g4")
             .expect("valid address")
             .assume_checked(),
@@ -707,9 +708,28 @@ mod test {
         Ok(())
     }
 
+    #[test]
+    fn default_expiry() {
+        let now = SystemTime::now();
+
+        let session = NewReceiver::new(
+            SHARED_CONTEXT.address.clone(),
+            SHARED_CONTEXT.directory.clone(),
+            SHARED_CONTEXT.ohttp_keys.clone(),
+            None,
+        );
+        let session_expiry = session.unwrap().context.expiry.duration_since(now).unwrap().as_secs();
+        let default_expiry = Duration::from_secs(86400);
+        if let Some(expected_expiry) = now.checked_add(default_expiry) {
+            assert_eq!(TWENTY_FOUR_HOURS_DEFAULT_EXPIRY, default_expiry);
+            assert_eq!(session_expiry, expected_expiry.duration_since(now).unwrap().as_secs());
+        }
+    }
+
     #[test]
     fn receiver_ser_de_roundtrip() -> Result<(), serde_json::Error> {
         let session = Receiver { context: SHARED_CONTEXT.clone() };
+        assert_eq!(session.key().as_ref(), session.key().0.as_bytes());
         let serialized = serde_json::to_string(&session)?;
         let deserialized: Receiver = serde_json::from_str(&serialized)?;
         assert_eq!(session, deserialized);