chore: use variables directly in format! string

Author: bitfl0wer

src/constraints/types/domain_name.rs

@@ -50,18 +50,15 @@ mod tests {
             let domain_name = DomainName::new(case).unwrap();
             assert!(
                 domain_name.validate(None).is_ok(),
-                "DomainName '{}' should validate",
-                case
+                "DomainName '{case}' should validate"
             );
             assert!(
                 domain_name.validate(Some(Target::Actor)).is_ok(),
-                "DomainName '{}' should validate with Actor target",
-                case
+                "DomainName '{case}' should validate with Actor target"
             );
             assert!(
                 domain_name.validate(Some(Target::HomeServer)).is_ok(),
-                "DomainName '{}' should validate with HomeServer target",
-                case
+                "DomainName '{case}' should validate with HomeServer target"
             );
         }
     }
@@ -110,8 +107,7 @@ mod tests {
             let result = DomainName::new(case);
             assert!(
                 result.is_err(),
-                "DomainName construction should fail for invalid format: '{}'",
-                case
+                "DomainName construction should fail for invalid format: '{case}'"
             );
         }
     }

src/constraints/types/federation_id.rs

@@ -47,18 +47,15 @@ mod tests {
             let federation_id = FederationId::new(case).unwrap();
             assert!(
                 federation_id.validate(None).is_ok(),
-                "FederationId '{}' should validate",
-                case
+                "FederationId '{case}' should validate"
             );
             assert!(
                 federation_id.validate(Some(Target::Actor)).is_ok(),
-                "FederationId '{}' should validate with Actor target",
-                case
+                "FederationId '{case}' should validate with Actor target"
             );
             assert!(
                 federation_id.validate(Some(Target::HomeServer)).is_ok(),
-                "FederationId '{}' should validate with HomeServer target",
-                case
+                "FederationId '{case}' should validate with HomeServer target"
             );
         }
     }
@@ -93,8 +90,7 @@ mod tests {
             let result = FederationId::new(case);
             assert!(
                 result.is_err(),
-                "FederationId construction should fail for invalid format: '{}'",
-                case
+                "FederationId construction should fail for invalid format: '{case}'"
             );
         }
     }

src/constraints/types/local_name.rs

@@ -44,18 +44,15 @@ mod tests {
             let local_name = LocalName::new(case).unwrap();
             assert!(
                 local_name.validate(None).is_ok(),
-                "LocalName '{}' should validate",
-                case
+                "LocalName '{case}' should validate"
             );
             assert!(
                 local_name.validate(Some(Target::Actor)).is_ok(),
-                "LocalName '{}' should validate with Actor target",
-                case
+                "LocalName '{case}' should validate with Actor target"
             );
             assert!(
                 local_name.validate(Some(Target::HomeServer)).is_ok(),
-                "LocalName '{}' should validate with HomeServer target",
-                case
+                "LocalName '{case}' should validate with HomeServer target"
             );
         }
     }
@@ -72,8 +69,7 @@ mod tests {
             let result = LocalName::new(case);
             assert!(
                 result.is_err(),
-                "LocalName construction should fail for invalid format: '{}'",
-                case
+                "LocalName construction should fail for invalid format: '{case}'"
             );
         }
     }
@@ -94,8 +90,7 @@ mod tests {
             let local_name = LocalName::new(case).unwrap();
             assert!(
                 local_name.validate(None).is_ok(),
-                "LocalName edge case '{}' should validate",
-                case
+                "LocalName edge case '{case}' should validate"
             );
         }
     }

src/types/spki/algorithmidentifierowned.rs

@@ -140,8 +140,8 @@ mod test {
         let json = json!(alg);
         let deserialized: AlgorithmIdentifierOwned = serde_json::from_value(json).unwrap();
         assert_eq!(alg, deserialized);
-        trace!("deserialized: {:?}", deserialized);
-        trace!("original: {:?}", alg);
+        trace!("deserialized: {deserialized:?}");
+        trace!("original: {alg:?}");
 
         let bytes = [48, 6, 6, 3, 43, 6, 1, 5, 1, 4, 5, 5, 23, 2, 0, 0];
         let bitstring = BitString::from_bytes(&bytes).unwrap();
@@ -151,8 +151,8 @@ mod test {
         );
         let json = json!(alg);
         let deserialized: AlgorithmIdentifierOwned = serde_json::from_value(json).unwrap();
-        trace!("deserialized: {:?}", deserialized);
-        trace!("original: {:?}", alg);
+        trace!("deserialized: {deserialized:?}");
+        trace!("original: {alg:?}");
         assert_eq!(alg, deserialized);
     }
 }

tests/types/pdn.rs

@@ -46,7 +46,7 @@ fn test_actor_dn_from_different_usernames() {
 
         // Convert to ActorDN - should succeed for all valid usernames
         let result = ActorDN::try_from(subject_name);
-        assert!(result.is_ok(), "Failed to convert valid certificate for user: {}", username);
+        assert!(result.is_ok(), "Failed to convert valid certificate for user: {username}");
     }
 }
 }
@@ -97,7 +97,7 @@ fn test_actor_dn_missing_federation_id() {
     assert!(result.is_err());
 
     let error = result.unwrap_err();
-    println!("Missing Federation ID error: {}", error);
+    println!("Missing Federation ID error: {error}");
     // This fails at the Name validation level before reaching ActorDN parsing
     assert!(error.to_string().contains("malformed") || error.to_string().contains("validation"));
 }
@@ -131,7 +131,7 @@ fn test_actor_dn_missing_session_id() {
     assert!(result.is_err());
 
     let error = result.unwrap_err();
-    println!("Missing Session ID error: {}", error);
+    println!("Missing Session ID error: {error}");
     // This fails at the Name validation level before reaching ActorDN parsing
     assert!(error.to_string().contains("expected to be between") || error.to_string().contains("malformed"));
 }
@@ -149,7 +149,7 @@ fn test_actor_dn_duplicate_oid_error() {
     assert!(result.is_err());
 
     let error = result.unwrap_err();
-    println!("Duplicate OID error: {}", error);
+    println!("Duplicate OID error: {error}");
     // This fails at the Name validation level before reaching ActorDN parsing
     assert!(error.to_string().contains("expected to be between") || error.to_string().contains("malformed"));
 }
@@ -186,7 +186,7 @@ fn test_actor_dn_roundtrip_conversion() {
 
         // Convert to ActorDN - should succeed for all valid users
         let result = ActorDN::try_from(original_subject.clone());
-        assert!(result.is_ok(), "Roundtrip conversion should succeed for user: {}", user);
+        assert!(result.is_ok(), "Roundtrip conversion should succeed for user: {user}");
     }
 }
 }