15595573901

Committed 11 Jun 2025 09:01PM UTC coverage: 85.952% (+0.3%) from 85.622%

Build # 15595573901

Build Type

Pull #748

github

Committed by

web-flow

Commit Message

Merge 376346073 into 8a6344ec6

Pull Request Pull Request #748: Full mutation coverage on send in the payjoin crate

Coverage Stats

100 of 103 new or added lines in 3 files covered. (97.09%)

19 existing lines in 3 files now uncovered.

7134 of 8300 relevant lines covered (85.95%)

559.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/payjoin/src/send/multiparty/error.rs

use std::fmt::{self, Display};

use bitcoin::psbt::Error as PsbtError;

use crate::hpke::HpkeError;
use crate::ohttp::OhttpEncapsulationError;
use crate::send::InternalProposalError;
use crate::uri::url_ext::ParseReceiverPubkeyParamError;
use crate::ImplementationError;

#[derive(Debug)]
pub struct CreateRequestError(InternalCreateRequestError);

#[derive(Debug)]
pub(crate) enum InternalCreateRequestError {
    #[allow(dead_code)]
    Expired(std::time::SystemTime),
    MissingOhttpConfig,
    ParseReceiverPubkeyParam(ParseReceiverPubkeyParamError),
    V2CreateRequest(crate::send::v2::CreateRequestError),
}

impl From<InternalCreateRequestError> for CreateRequestError {
    fn from(value: InternalCreateRequestError) -> Self { CreateRequestError(value) }
}

impl Display for CreateRequestError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self.0) }
}

impl std::error::Error for CreateRequestError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.0 {
            InternalCreateRequestError::Expired(_) => None,
            InternalCreateRequestError::MissingOhttpConfig => None,
            InternalCreateRequestError::ParseReceiverPubkeyParam(e) => Some(e),
            InternalCreateRequestError::V2CreateRequest(e) => Some(e),
        }
    }
}

#[derive(Debug)]
pub struct FinalizedError(InternalFinalizedError);

#[derive(Debug)]
pub(crate) enum InternalFinalizedError {
    Hpke(HpkeError),
    InvalidSize,
    #[allow(dead_code)]
    FinalizePsbt(ImplementationError),
    MissingResponse,
    Psbt(PsbtError),
    #[allow(dead_code)]
    UnexpectedStatusCode(http::StatusCode),
    Proposal(InternalProposalError),
    Ohttp(OhttpEncapsulationError),
}

impl From<InternalFinalizedError> for FinalizedError {
    fn from(value: InternalFinalizedError) -> Self { FinalizedError(value) }
}

impl Display for FinalizedError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self.0) }
}

impl std::error::Error for FinalizedError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.0 {
            InternalFinalizedError::Hpke(e) => Some(e),
            InternalFinalizedError::InvalidSize => None,
            InternalFinalizedError::FinalizePsbt(_) => None,
            InternalFinalizedError::MissingResponse => None,
            InternalFinalizedError::Psbt(e) => Some(e),
            InternalFinalizedError::UnexpectedStatusCode(_) => None,
            InternalFinalizedError::Proposal(e) => Some(e),
            InternalFinalizedError::Ohttp(e) => Some(e),
        }
    }
}

#[derive(Debug)]
pub struct FinalizeResponseError(InternalFinalizeResponseError);

#[derive(Debug)]
pub(crate) enum InternalFinalizeResponseError {
    #[allow(dead_code)]
    InvalidSize(usize),
    Ohttp(OhttpEncapsulationError),
    #[allow(dead_code)]
    UnexpectedStatusCode(http::StatusCode),
}

impl From<InternalFinalizeResponseError> for FinalizeResponseError {
    fn from(value: InternalFinalizeResponseError) -> Self { FinalizeResponseError(value) }
}

impl Display for FinalizeResponseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self.0) }
}

impl std::error::Error for FinalizeResponseError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.0 {
            InternalFinalizeResponseError::InvalidSize(_) => None,
            InternalFinalizeResponseError::Ohttp(e) => Some(e),
            InternalFinalizeResponseError::UnexpectedStatusCode(_) => None,
        }
    }
}

1	use std::fmt::{self, Display};
2
3	use bitcoin::psbt::Error as PsbtError;
4
5	use crate::hpke::HpkeError;
6	use crate::ohttp::OhttpEncapsulationError;
7	use crate::send::InternalProposalError;
8	use crate::uri::url_ext::ParseReceiverPubkeyParamError;
9	use crate::ImplementationError;
10
11	#[derive(Debug)]
12	pub struct CreateRequestError(InternalCreateRequestError);
13
14	#[derive(Debug)]
15	pub(crate) enum InternalCreateRequestError {
16	#[allow(dead_code)]
17	Expired(std::time::SystemTime),
18	MissingOhttpConfig,
19	ParseReceiverPubkeyParam(ParseReceiverPubkeyParamError),
20	V2CreateRequest(crate::send::v2::CreateRequestError),
21	}
22
23	impl From<InternalCreateRequestError> for CreateRequestError {
24	fn from(value: InternalCreateRequestError) -> Self { CreateRequestError(value) }	×
25	}
26
27	impl Display for CreateRequestError {
28	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self.0) }	×
29	}
30
31	impl std::error::Error for CreateRequestError {
32	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {	×
33	match &self.0 {	×
34	InternalCreateRequestError::Expired(_) => None,	×
35	InternalCreateRequestError::MissingOhttpConfig => None,	×
36	InternalCreateRequestError::ParseReceiverPubkeyParam(e) => Some(e),	×
37	InternalCreateRequestError::V2CreateRequest(e) => Some(e),	×
38	}
39	}	×
40	}
41
42	#[derive(Debug)]
43	pub struct FinalizedError(InternalFinalizedError);
44
45	#[derive(Debug)]
46	pub(crate) enum InternalFinalizedError {
47	Hpke(HpkeError),
48	InvalidSize,
49	#[allow(dead_code)]
50	FinalizePsbt(ImplementationError),
51	MissingResponse,
52	Psbt(PsbtError),
53	#[allow(dead_code)]
54	UnexpectedStatusCode(http::StatusCode),
55	Proposal(InternalProposalError),
56	Ohttp(OhttpEncapsulationError),
57	}
58
59	impl From<InternalFinalizedError> for FinalizedError {
60	fn from(value: InternalFinalizedError) -> Self { FinalizedError(value) }	×
61	}
62
63	impl Display for FinalizedError {
64	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self.0) }	×
65	}
66
67	impl std::error::Error for FinalizedError {
UNCOV 68	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {	×
UNCOV 69	match &self.0 {	×
UNCOV 70	InternalFinalizedError::Hpke(e) => Some(e),	×
71	InternalFinalizedError::InvalidSize => None,	×
72	InternalFinalizedError::FinalizePsbt(_) => None,	×
73	InternalFinalizedError::MissingResponse => None,	×
74	InternalFinalizedError::Psbt(e) => Some(e),	×
75	InternalFinalizedError::UnexpectedStatusCode(_) => None,	×
76	InternalFinalizedError::Proposal(e) => Some(e),	×
77	InternalFinalizedError::Ohttp(e) => Some(e),	×
78	}
UNCOV 79	}	×
80	}
81
82	#[derive(Debug)]
83	pub struct FinalizeResponseError(InternalFinalizeResponseError);
84
85	#[derive(Debug)]
86	pub(crate) enum InternalFinalizeResponseError {
87	#[allow(dead_code)]
88	InvalidSize(usize),
89	Ohttp(OhttpEncapsulationError),
90	#[allow(dead_code)]
91	UnexpectedStatusCode(http::StatusCode),
92	}
93
94	impl From<InternalFinalizeResponseError> for FinalizeResponseError {
95	fn from(value: InternalFinalizeResponseError) -> Self { FinalizeResponseError(value) }	×
96	}
97
98	impl Display for FinalizeResponseError {
99	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self.0) }	×
100	}
101
102	impl std::error::Error for FinalizeResponseError {
UNCOV 103	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {	×
UNCOV 104	match &self.0 {	×
UNCOV 105	InternalFinalizeResponseError::InvalidSize(_) => None,	×
106	InternalFinalizeResponseError::Ohttp(e) => Some(e),	×
107	InternalFinalizeResponseError::UnexpectedStatusCode(_) => None,	×
108	}
109	}	×
110	}

payjoin / rust-payjoin / 15595573901

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous