try excluding trace! calls to increase coverage

bitfl0wer · bitfl0wer · commit 101a9ceea722 · 2025-02-23T14:48:04.000+01:00
diff --git a/src/api/core/cacheable_cert.rs b/src/api/core/cacheable_cert.rs
@@ -153,9 +153,13 @@ impl CacheableIdCert {
                     ))),
                 )
             })?;
+        #[cfg(not(tarpaulin_include))]
         trace!("Serial number: {}", serial_number);
+        #[cfg(not(tarpaulin_include))]
         trace!("Not valid before: {}", &self.not_valid_before.to_string());
+        #[cfg(not(tarpaulin_include))]
         trace!("Not valid after: {}", &self.not_valid_after.to_string());
+        #[cfg(not(tarpaulin_include))]
         trace!(
             "Invalidated at: {}",
             &self
@@ -170,6 +174,7 @@ impl CacheableIdCert {
                 .invalidated_at
                 .map(|v| v.to_string())
                 .unwrap_or("".to_string());
+        #[cfg(not(tarpaulin_include))]
         trace!("Computed string: {}", string_to_check);
         verifying_key
             .verify_signature(
diff --git a/src/api/core/mod.rs b/src/api/core/mod.rs
@@ -119,9 +119,9 @@ impl<S: Signature, T: PrivateKey<S>> Session<S, T> {
         Ok(())
     }
 
-    /// Retrieve encrypted private key material from the server. The serial_numbers, if provided,
+    /// Retrieve encrypted private key material from the server. The `serial_numbers`, if provided,
     /// must match the serial numbers of ID-Certs that the client has uploaded key material for.
-    /// If no serial_numbers are provided, the server will return all key material that the client
+    /// If no `serial_numbers` are provided, the server will return all key material that the client
     /// has uploaded.
     pub async fn get_encrypted_pkm(
         &self,
@@ -269,6 +269,7 @@ impl HttpClient {
             request = request.body(json!({ "timestamp": time }).to_string());
         }
         let response = request.send().await;
+        #[cfg(not(tarpaulin_include))]
         trace!("Got response: {:?}", response);
         let id_cert = HttpClient::handle_response::<CacheableIdCert>(response).await?;
         Ok(id_cert)
diff --git a/src/certs/capabilities/basic_constraints.rs b/src/certs/capabilities/basic_constraints.rs
@@ -165,8 +165,10 @@ impl TryFrom<Extension> for BasicConstraints {
     /// this property is critical, use the [Constrained] trait to verify the well-formedness of
     /// these resulting [BasicConstraints].
     fn try_from(value: Extension) -> Result<Self, Self::Error> {
-        trace!("Converting Extension to BasicConstraints");
-        trace!("Extension: {:#?}", value);
+        #[cfg(not(tarpaulin_include))]
+trace!("Converting Extension to BasicConstraints");
+        #[cfg(not(tarpaulin_include))]
+trace!("Extension: {:#?}", value);
         #[allow(unreachable_patterns)]
         if value.critical && !matches!(value.extn_id.to_string().as_str(), OID_BASIC_CONSTRAINTS) {
             // Error if we encounter a "critical" X.509 extension which we do not know of
diff --git a/src/certs/capabilities/key_usage.rs b/src/certs/capabilities/key_usage.rs
@@ -6,6 +6,7 @@ use std::str::FromStr;
 
 use der::asn1::{BitString, OctetString, SetOfVec};
 use der::{Any, Decode, Encode, Tag, Tagged};
+use log::trace;
 use spki::ObjectIdentifier;
 use x509_cert::attr::Attribute;
 use x509_cert::ext::Extension;
@@ -90,7 +91,8 @@ impl KeyUsages {
     /// ```
     pub fn from_bitstring(bitstring: BitString) -> Result<Self, ConversionError> {
         let mut byte_array = bitstring.raw_bytes().to_vec();
-        log::trace!("[from_bitstring] BitString raw bytes: {:?}", byte_array);
+        #[cfg(not(tarpaulin_include))]
+        trace!("[from_bitstring] BitString raw bytes: {:?}", byte_array);
         let mut key_usages = Vec::new();
         if byte_array == [0] || byte_array.is_empty() {
             // TODO: PLEASE write a test for this. Is an empty byte array valid? Is a byte array with a single 0 valid, and does it mean that no KeyUsage is set? -bitfl0wer
diff --git a/src/certs/idcert.rs b/src/certs/idcert.rs
@@ -5,6 +5,7 @@
 use der::asn1::Uint;
 use der::pem::LineEnding;
 use der::{Decode, DecodePem, Encode, EncodePem};
+use log::trace;
 use x509_cert::name::Name;
 use x509_cert::time::Validity;
 use x509_cert::Certificate;
@@ -126,14 +127,19 @@ impl<S: Signature, P: PublicKey<S>> IdCert<S, P> {
         issuer: Name,
         validity: Validity,
     ) -> Result<Self, ConversionError> {
-        log::trace!("[IdCert::from_actor_csr()] creating actor certificate");
+        #[cfg(not(tarpaulin_include))]
+        trace!("[IdCert::from_actor_csr()] creating actor certificate");
         let signature_algorithm = signing_key.algorithm_identifier();
-        log::trace!("[IdCert::from_actor_csr()] creating IdCertTbs");
-        log::trace!("[IdCert::from_actor_csr()] Issuer: {}", issuer.to_string());
-        log::trace!(
-            "[IdCert::from_actor_csr()] Subject: {}",
-            id_csr.inner_csr.subject.to_string()
-        );
+        #[cfg(not(tarpaulin_include))]
+        {
+            trace!("[IdCert::from_actor_csr()] creating IdCertTbs");
+            trace!("[IdCert::from_actor_csr()] Issuer: {}", issuer.to_string());
+            trace!(
+                "[IdCert::from_actor_csr()] Subject: {}",
+                id_csr.inner_csr.subject.to_string()
+            );
+        }
+
         let id_cert_tbs = IdCertTbs::<S, P> {
             serial_number,
             signature_algorithm,
@@ -144,13 +150,15 @@ impl<S: Signature, P: PublicKey<S>> IdCert<S, P> {
             capabilities: id_csr.inner_csr.capabilities,
             s: std::marker::PhantomData,
         };
-        log::trace!("[IdCert::from_actor_csr()] creating Signature");
+        #[cfg(not(tarpaulin_include))]
+        trace!("[IdCert::from_actor_csr()] creating Signature");
         let signature = signing_key.sign(&id_cert_tbs.clone().to_der()?);
         let cert = IdCert {
             id_cert_tbs,
             signature,
         };
-        log::trace!(
+        #[cfg(not(tarpaulin_include))]
+        trace!(
             "[IdCert::from_actor_csr()] validating certificate with target {:?}",
             Some(Target::Actor)
         );
@@ -285,7 +293,8 @@ impl<S: Signature, P: PublicKey<S>> IdCert<S, P> {
             return Err(InvalidCert::InvalidValidity);
         }
         self.validate(Some(Target::Actor))?;
-        log::trace!("[IdCert::full_verify_actor(&self)] verifying signature (actor certificate)");
+        #[cfg(not(tarpaulin_include))]
+        trace!("[IdCert::full_verify_actor(&self)] verifying signature (actor certificate)");
         let der = match self.id_cert_tbs.clone().to_der() {
             Ok(der) => der,
             Err(_) => {
@@ -332,9 +341,8 @@ impl<S: Signature, P: PublicKey<S>> IdCert<S, P> {
                 )));
             }
         };
-        log::trace!(
-            "[IdCert::full_verify_home_server(&self)] verifying signature (self-signed IdCert)"
-        );
+        #[cfg(not(tarpaulin_include))]
+        trace!("[IdCert::full_verify_home_server(&self)] verifying signature (self-signed IdCert)");
         Ok(self
             .id_cert_tbs
             .subject_public_key
diff --git a/src/certs/idcerttbs.rs b/src/certs/idcerttbs.rs
@@ -213,7 +213,8 @@ fn rdns_to_url(rdn_sequence: &RdnSequence) -> Result<url::Url, url::ParseError>
         url_str += ".";
     }
     let _ = url_str.pop();
-    trace!(r#"Trying to parse string "{}" as url::Url..."#, url_str);
+    #[cfg(not(tarpaulin_include))]
+trace!(r#"Trying to parse string "{}" as url::Url..."#, url_str);
     Url::parse(url_str.trim())
 }
 
diff --git a/src/certs/idcsr.rs b/src/certs/idcsr.rs
@@ -6,6 +6,7 @@ use std::marker::PhantomData;
 
 use der::pem::LineEnding;
 use der::{Decode, DecodePem, Encode, EncodePem};
+use log::trace;
 use spki::AlgorithmIdentifierOwned;
 use x509_cert::attr::Attributes;
 use x509_cert::name::Name;
@@ -84,7 +85,8 @@ impl<S: Signature, P: PublicKey<S>> IdCsr<S, P> {
             signature_algorithm,
             signature,
         };
-        log::trace!("[IdCsr::new()] Validating self with Target: {:?}", target);
+        #[cfg(not(tarpaulin_include))]
+        trace!("[IdCsr::new()] Validating self with Target: {:?}", target);
         id_csr.validate(target)?;
         Ok(id_csr)
     }
diff --git a/src/constraints/certs.rs b/src/constraints/certs.rs
@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use log::{debug, warn};
+use log::{debug, trace, warn};
 
 use crate::errors::{
     ERR_MSG_ACTOR_CANNOT_BE_CA, ERR_MSG_DC_MISMATCH_ISSUER_SUBJECT,
@@ -13,12 +13,14 @@ use super::*;
 
 impl<S: Signature, P: PublicKey<S>> Constrained for IdCsrInner<S, P> {
     fn validate(&self, target: Option<Target>) -> Result<(), ConstraintError> {
-        log::trace!(
+        #[cfg(not(tarpaulin_include))]
+        trace!(
             "[IdCsrInner::validate()] validating capabilities for target: {:?}",
             target
         );
         self.capabilities.validate(target)?;
-        log::trace!(
+        #[cfg(not(tarpaulin_include))]
+        trace!(
             "[IdCsrInner::validate()] validating subject for target: {:?}",
             target
         );
@@ -47,12 +49,13 @@ impl<S: Signature, P: PublicKey<S>> Constrained for IdCsrInner<S, P> {
 
 impl<S: Signature, P: PublicKey<S>> Constrained for IdCsr<S, P> {
     fn validate(&self, target: Option<Target>) -> Result<(), ConstraintError> {
-        log::trace!(
+        trace!(
             "[IdCsr::validate()] validating inner CSR with target {:?}",
             target
         );
         self.inner_csr.validate(target)?;
-        log::trace!("[IdCsr::validate()] verifying signature");
+        #[cfg(not(tarpaulin_include))]
+        trace!("[IdCsr::validate()] verifying signature");
         match self.inner_csr.subject_public_key.verify_signature(
             &self.signature,
             match &self.inner_csr.clone().to_der() {
@@ -74,7 +77,8 @@ impl<S: Signature, P: PublicKey<S>> Constrained for IdCsr<S, P> {
 
 impl<S: Signature, P: PublicKey<S>> Constrained for IdCert<S, P> {
     fn validate(&self, target: Option<Target>) -> Result<(), ConstraintError> {
-        log::trace!(
+        #[cfg(not(tarpaulin_include))]
+        trace!(
             "[IdCert::validate()] validating inner IdCertTbs with target {:?}",
             target
         );
@@ -85,7 +89,8 @@ impl<S: Signature, P: PublicKey<S>> Constrained for IdCert<S, P> {
 
 impl<S: Signature, P: PublicKey<S>> Constrained for IdCertTbs<S, P> {
     fn validate(&self, target: Option<Target>) -> Result<(), ConstraintError> {
-        log::trace!(
+        #[cfg(not(tarpaulin_include))]
+        trace!(
             "[IdCertTbs::validate()] validating if DER encoding is intact for certificate serial {:?}",
             self.serial_number
         );
@@ -101,25 +106,30 @@ impl<S: Signature, P: PublicKey<S>> Constrained for IdCertTbs<S, P> {
                 )));
             }
         };
-        log::trace!(
+        #[cfg(not(tarpaulin_include))]
+        trace!(
             "[IdCertTbs::validate()] validating capabilities for target: {:?}",
             target
         );
         self.capabilities.validate(target)?;
         dbg!(self.issuer.to_string());
         self.issuer.validate(Some(Target::HomeServer))?;
         self.subject.validate(target)?;
-        log::trace!(
-            "[IdCertTbs::validate()] checking if domain components of issuer and subject are equal"
-        );
-        log::trace!(
-            "[IdCertTbs::validate()] Issuer: {}",
-            self.issuer.to_string()
-        );
-        log::trace!(
-            "[IdCertTbs::validate()] Subject: {}",
-            self.subject.to_string()
-        );
+        #[cfg(not(tarpaulin_include))]
+        {
+            trace!(
+                "[IdCertTbs::validate()] checking if domain components of issuer and subject are equal"
+            );
+            trace!(
+                "[IdCertTbs::validate()] Issuer: {}",
+                self.issuer.to_string()
+            );
+            trace!(
+                "[IdCertTbs::validate()] Subject: {}",
+                self.subject.to_string()
+            );
+        }
+
         match equal_domain_components(&self.issuer, &self.subject) {
             true => debug!("Domain components of issuer and subject are equal"),
             false => {
diff --git a/src/constraints/name.rs b/src/constraints/name.rs
@@ -23,7 +23,8 @@ impl Constrained for Name {
     /// - MAY have other attributes, which might be ignored by other home servers and other clients.
     // I apologize. This is horrible. I'll redo it eventually. Depression made me do it. -bitfl0wer
     fn validate(&self, target: Option<Target>) -> Result<(), ConstraintError> {
-        log::trace!("[Name::validate()] Validating Name: {}", self.to_string());
+        #[cfg(not(tarpaulin_include))]
+        trace!("[Name::validate()] Validating Name: {}", self.to_string());
         let mut num_cn: u8 = 0;
         let mut num_dc: u8 = 0;
         let mut num_uid: u8 = 0;
@@ -34,28 +35,32 @@ impl Constrained for Name {
 
         let rdns = &self.0;
         for rdn in rdns.iter() {
-            log::trace!(
+            #[cfg(not(tarpaulin_include))]
+            trace!(
                 "[Name::validate()] Determining OID of RDN {} and performing appropriate validation",
                 rdn.to_string()
             );
             for item in rdn.0.iter() {
                 match item.oid.to_string().as_str() {
                     OID_RDN_UID => {
-                        log::trace!("[Name::validate()] Found UID in RDN: {}", item.to_string());
+                        #[cfg(not(tarpaulin_include))]
+                        trace!("[Name::validate()] Found UID in RDN: {}", item.to_string());
                         num_uid += 1;
                         uid = rdn.clone();
                         validate_rdn_uid(item)?;
                     }
                     OID_RDN_UNIQUE_IDENTIFIER => {
-                        log::trace!(
+                        #[cfg(not(tarpaulin_include))]
+                        trace!(
                             "[Name::validate()] Found uniqueIdentifier in RDN: {}",
                             item.to_string()
                         );
                         num_unique_identifier += 1;
                         validate_rdn_unique_identifier(item)?;
                     }
                     OID_RDN_COMMON_NAME => {
-                        log::trace!(
+                        #[cfg(not(tarpaulin_include))]
+                        trace!(
                             "[Name::validate()] Found Common Name in RDN: {}",
                             item.to_string()
                         );
@@ -71,15 +76,17 @@ impl Constrained for Name {
                         }
                     }
                     OID_RDN_DOMAIN_COMPONENT => {
-                        log::trace!(
+                        #[cfg(not(tarpaulin_include))]
+                        trace!(
                             "[Name::validate()] Found Domain Component in RDN: {}",
                             item.to_string()
                         );
                         num_dc += 1;
                         vec_dc.push(rdn.clone());
                     }
                     _ => {
-                        log::trace!(
+                        #[cfg(not(tarpaulin_include))]
+                        trace!(
                             "[Name::validate()] Found unknown/non-validated component in RDN: {}",
                             item.to_string()
                         );
@@ -92,7 +99,8 @@ impl Constrained for Name {
         if let Some(target) = target {
             match target {
                 Target::Actor => {
-                    log::trace!(
+                    #[cfg(not(tarpaulin_include))]
+                    trace!(
                         "[Name::validate()] Validating DC {:?} matches DC in UID {}",
                         vec_dc
                             .iter()
@@ -117,13 +125,16 @@ impl Constrained for Name {
         } else if num_uid != 0 {
             validate_dc_matches_dc_in_uid(&vec_dc, &uid)?;
         }
-        log::trace!(
+
+        #[cfg(not(tarpaulin_include))]
+        trace!(
             "Encountered {} UID components and {} Common Name components",
             num_uid,
             num_cn
         );
         if num_uid != 0 && num_cn != 0 {
-            log::trace!("Validating UID username matches Common Name");
+            #[cfg(not(tarpaulin_include))]
+            trace!("Validating UID username matches Common Name");
             validate_uid_username_matches_cn(&uid, &cn)?;
         }
         if num_dc == 0 {
@@ -196,6 +207,8 @@ fn validate_dc_matches_dc_in_uid(
     // Split the UID at the @
     let uid_without_username = uid.to_string().split_at(position_of_at + 1).1.to_string(); // +1 to not include the @
     let dc_normalized_uid: Vec<&str> = uid_without_username.split('.').collect();
+    #[cfg(not(tarpaulin_include))]
+    #[cfg(not(tarpaulin_include))]
     trace!("UID domain components: {:?}", dc_normalized_uid.clone());
     let mut index = 0u8;
     // Iterate over the DCs in the UID and check if they are equal to the DCs in the vec of DCs
@@ -208,6 +221,8 @@ fn validate_dc_matches_dc_in_uid(
                 )))
             }
         };
+        #[cfg(not(tarpaulin_include))]
+        #[cfg(not(tarpaulin_include))]
         trace!("Found an equivalent domain component: {}", equivalent_dc);
         let equivalent_dc = equivalent_dc.to_string().split_at(3).1.to_string();
         if component != &equivalent_dc.to_string() {
diff --git a/src/types/spki/algorithmidentifierowned.rs b/src/types/spki/algorithmidentifierowned.rs
diff --git a/src/types/x509_cert/serialnumber.rs b/src/types/x509_cert/serialnumber.rs
diff --git a/tests/certs/capabilities/key_usage.rs b/tests/certs/capabilities/key_usage.rs
diff --git a/tests/certs/idcert.rs b/tests/certs/idcert.rs

Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,8 @@ fn rdns_to_url(rdn_sequence: &RdnSequence) -> Result<url::Url, url::ParseError>`
`213`	`213`	`url_str += ".";`
`214`	`214`	`}`
`215`	`215`	`let _ = url_str.pop();`
`216`		`- trace!(r#"Trying to parse string "{}" as url::Url..."#, url_str);`
	`216`	`+ #[cfg(not(tarpaulin_include))]`
	`217`	`+trace!(r#"Trying to parse string "{}" as url::Url..."#, url_str);`
`217`	`218`	`Url::parse(url_str.trim())`
`218`	`219`	`}`
`219`	`220`