Catch new match arm cargo mutants (payjoin#686)

The newest version of cargo mutants v25.0.1 added a new type of mutation
that attempts to delete entire match arms.

Mutants passing on 7b3ea49

`259 mutants tested in 8m 49s: 163 caught, 96 unviable`

Closes payjoin#671

Author: spacebear21

payjoin/src/receive/optional_parameters.rs

@@ -105,7 +105,7 @@ impl Params {
             (Some(_), None) | (None, Some(_)) => {
                 warn!("only one additional-fee parameter specified: {params:?}");
             }
-            _ => (),
+            (None, None) => (),
         }
 
         log::debug!("parsed optional parameters: {params:?}");
@@ -134,23 +134,24 @@ impl std::error::Error for Error {
 
 #[cfg(test)]
 pub(crate) mod test {
-    use bitcoin::Amount;
+    use bitcoin::{Amount, FeeRate};
 
     use super::*;
     use crate::receive::optional_parameters::Params;
     use crate::Version;
 
     #[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 pairs = url::form_urlencoded::parse(b"&maxadditionalfeecontribution=182&additionalfeeoutputindex=0&minfeerate=2&disableoutputsubstitution=true&optimisticmerge=true");
         let params = Params::from_query_pairs(pairs, &[Version::One])
             .expect("Could not parse params from query pairs");
         assert_eq!(params.v, Version::One);
         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);
+        assert_eq!(
+            params.min_fee_rate,
+            FeeRate::from_sat_per_vb(2).expect("Could not calculate feerate")
+        );
         #[cfg(feature = "_multiparty")]
         assert!(params.optimistic_merge)
     }

payjoin/src/uri/error.rs

@@ -1,7 +1,7 @@
 use url::ParseError;
 
 #[derive(Debug)]
-pub struct PjParseError(InternalPjParseError);
+pub struct PjParseError(pub(crate) InternalPjParseError);
 
 #[derive(Debug)]
 pub(crate) enum InternalPjParseError {

payjoin/src/uri/mod.rs

@@ -315,6 +315,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_pj_duplicate_params() {
+        let uri =
+            "bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX?pjos=1&pjos=1&pj=HTTPS://EXAMPLE.COM/\
+                   %23OH1QYPM5JXYNS754Y4R45QWE336QFX6ZR8DQGVQCULVZTV20TFVEYDMFQC";
+        let pjuri = Uri::try_from(uri);
+        assert!(matches!(
+            pjuri,
+            Err(bitcoin_uri::de::Error::Extras(PjParseError(
+                InternalPjParseError::DuplicateParams("pjos")
+            )))
+        ));
+        let uri =
+            "bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX?pjos=1&pj=HTTPS://EXAMPLE.COM/\
+                   %23OH1QYPM5JXYNS754Y4R45QWE336QFX6ZR8DQGVQCULVZTV20TFVEYDMFQC&pj=HTTPS://EXAMPLE.COM/\
+                   %23OH1QYPM5JXYNS754Y4R45QWE336QFX6ZR8DQGVQCULVZTV20TFVEYDMFQC";
+        let pjuri = Uri::try_from(uri);
+        assert!(matches!(
+            pjuri,
+            Err(bitcoin_uri::de::Error::Extras(PjParseError(
+                InternalPjParseError::DuplicateParams("pj")
+            )))
+        ));
+    }
+
     #[test]
     fn test_serialize_pjos() {
         let uri = "bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX?pj=HTTPS://EXAMPLE.COM/%23OH1QYPM5JXYNS754Y4R45QWE336QFX6ZR8DQGVQCULVZTV20TFVEYDMFQC";

payjoin/tests/integration.rs

@@ -282,6 +282,119 @@ mod integration {
             Ok(())
         }
 
+        #[tokio::test]
+        async fn test_err_response() -> Result<(), BoxSendSyncError> {
+            init_tracing();
+            let mut services = TestServices::initialize().await?;
+            let result = tokio::select!(
+            err = services.take_ohttp_relay_handle() => panic!("Ohttp relay exited early: {:?}", err),
+            err = services.take_directory_handle() => panic!("Directory server exited early: {:?}", err),
+            res = process_err_res(&services) => res
+            );
+
+            assert!(result.is_ok(), "v2 send receive failed: {:#?}", result.unwrap_err());
+
+            async fn process_err_res(services: &TestServices) -> Result<(), BoxError> {
+                let (_bitcoind, sender, receiver) = init_bitcoind_sender_receiver(None, None)?;
+                let agent = services.http_agent();
+                services.wait_for_services_ready().await?;
+                let directory = services.directory_url();
+                let ohttp_keys = services.fetch_ohttp_keys().await?;
+                // **********************
+                // Inside the Receiver:
+                let address = receiver.get_new_address(None, None)?.assume_checked();
+
+                let new_receiver =
+                    NewReceiver::new(address.clone(), directory.clone(), ohttp_keys.clone(), None)?;
+                let storage_token =
+                    new_receiver.persist(&mut NoopPersister).map_err(|e| e.to_string())?;
+                let mut session =
+                    Receiver::load(storage_token, &NoopPersister).map_err(|e| e.to_string())?;
+                println!("session: {:#?}", &session);
+                // Poll receive request
+                let ohttp_relay = services.ohttp_relay_url();
+                let (req, ctx) = session.extract_req(&ohttp_relay)?;
+                let response = agent
+                    .post(req.url)
+                    .header("Content-Type", req.content_type)
+                    .body(req.body)
+                    .send()
+                    .await?;
+                assert!(response.status().is_success(), "error response: {}", response.status());
+                let response_body =
+                    session.process_res(response.bytes().await?.to_vec().as_slice(), ctx)?;
+                // No proposal yet since sender has not responded
+                assert!(response_body.is_none());
+
+                // **********************
+                // Inside the Sender:
+                // Create a funded PSBT (not broadcasted) to address with amount given in the pj_uri
+                let pj_uri = Uri::from_str(&session.pj_uri().to_string())
+                    .map_err(|e| e.to_string())?
+                    .assume_checked()
+                    .check_pj_supported()
+                    .map_err(|e| e.to_string())?;
+                let psbt = build_sweep_psbt(&sender, &pj_uri)?;
+                let new_sender =
+                    SenderBuilder::new(psbt, pj_uri).build_recommended(FeeRate::BROADCAST_MIN)?;
+                let storage_token =
+                    new_sender.persist(&mut NoopPersister).map_err(|e| e.to_string())?;
+                let req_ctx =
+                    Sender::load(storage_token, &NoopPersister).map_err(|e| e.to_string())?;
+                let (Request { url, body, content_type, .. }, _send_ctx) =
+                    req_ctx.extract_v2(ohttp_relay.to_owned())?;
+                let response = agent
+                    .post(url.clone())
+                    .header("Content-Type", content_type)
+                    .body(body.clone())
+                    .send()
+                    .await?;
+                log::info!("Response: {:#?}", &response);
+                assert!(response.status().is_success(), "error response: {}", response.status());
+                // POST Original PSBT
+
+                // **********************
+                // Inside the Receiver:
+
+                // GET fallback psbt
+                let (req, ctx) = session.extract_req(&ohttp_relay)?;
+                let response = agent
+                    .post(req.url)
+                    .header("Content-Type", req.content_type)
+                    .body(req.body)
+                    .send()
+                    .await?;
+                // POST payjoin
+                let mut proposal = session
+                    .process_res(response.bytes().await?.to_vec().as_slice(), ctx)?
+                    .expect("proposal should exist");
+                // Generate replyable error
+                let server_error = || {
+                    proposal
+                        .clone()
+                        .check_broadcast_suitability(None, |_| Err("mock error".into()))
+                        .expect_err("expected broadcast suitability check to fail")
+                };
+
+                let (err_req, err_ctx) =
+                    proposal.clone().extract_err_req(&server_error().into(), ohttp_relay)?;
+                let err_response = agent
+                    .post(err_req.url)
+                    .header("Content-Type", err_req.content_type)
+                    .body(err_req.body)
+                    .send()
+                    .await?;
+
+                let err_bytes = err_response.bytes().await?;
+                // Ensure that the error was handled properly
+                assert!(proposal.process_err_res(&err_bytes, err_ctx).is_ok());
+
+                Ok(())
+            }
+
+            Ok(())
+        }
+
         #[tokio::test]
         async fn v2_to_v2() -> Result<(), BoxSendSyncError> {
             init_tracing();