fix: clippyisms

server/lib/src/idm/credupdatesession.rs

@@ -3397,7 +3397,7 @@ mod tests {
         assert!(
             matches!(
                 c_status.mfaregstate,
-                MfaRegStateStatus::TotpNameTryAgain(ref val) if val == ""
+                MfaRegStateStatus::TotpNameTryAgain(ref val) if val.is_empty()
             ),
             "{:?}",
             c_status.mfaregstate

server/lib/src/idm/ldap.rs

@@ -1209,7 +1209,7 @@ mod tests {
         // Searching a malformed spn shouldn't cause the query to fail
         let sr = SearchRequest {
             msgid: 1,
-            base: format!("dc=example,dc=com"),
+            base: "dc=example,dc=com".to_string(),
             scope: LdapSearchScope::Subtree,
             filter: LdapFilter::Or(vec![
                 LdapFilter::Equality(Attribute::Name.to_string(), usr_name.to_string()),
@@ -1232,7 +1232,7 @@ mod tests {
 
         let sr = SearchRequest {
             msgid: 1,
-            base: format!("dc=example,dc=com"),
+            base: "dc=example,dc=com".to_string(),
             scope: LdapSearchScope::Subtree,
             filter: LdapFilter::And(vec![
                 LdapFilter::Equality(Attribute::Name.to_string(), usr_name.to_string()),

server/lib/src/idm/oauth2.rs

@@ -7314,10 +7314,7 @@ mod tests {
             &Url::parse(example_is_not_local)
                 .expect("Failed to parse example.com as a host?")
                 .host()
-                .expect(&format!(
+                .unwrap_or_else(|| panic!("Couldn't get a host from {}", example_is_not_local))
-                    "Couldn't get a host from {}",
-                    example_is_not_local
-                ))
         ));
 
         let test_urls = [

server/lib/src/repl/entry.rs

@@ -217,9 +217,9 @@ impl EntryChangeState {
     }
 
     #[cfg(test)]
-    pub(crate) fn get_attr_cid(&self, attr: Attribute) -> Option<&Cid> {
+    pub(crate) fn get_attr_cid(&self, attr: &Attribute) -> Option<&Cid> {
         match &self.st {
-            State::Live { at: _, changes } => changes.get(&attr),
+            State::Live { at: _, changes } => changes.get(attr),
             State::Tombstone { at: _ } => None,
         }
     }

server/lib/src/repl/tests.rs

@@ -705,7 +705,7 @@ async fn test_repl_increment_basic_deleted_attr(server_a: &QueryServer, server_b
     let e1_cs = e1.get_changestate();
     let e2_cs = e2.get_changestate();
     assert_eq!(e1_cs, e2_cs);
-    assert!(e1_cs.get_attr_cid(Attribute::Description).is_some());
+    assert!(e1_cs.get_attr_cid(&Attribute::Description).is_some());
 
     server_b_txn.commit().expect("Failed to commit");
     drop(server_a_txn);

server/lib/src/testkit.rs

@@ -4,12 +4,19 @@ use crate::schema::Schema;
 
 pub struct TestConfiguration {
     pub domain_level: DomainVersion,
+    // This is literally here to make clippy happy, just leave it alone!
+    // if you don't believe me then remove it and run 'cargo clippy --all-targets' it'll complain
+    // about "struct update has no effect, all the fields in the struct have already been specified"
+    // because the domain_level was set, then we ..Default::default() the "rest"
+    #[allow(dead_code)]
+    pub ignore_this_field: bool,
 }
 
 impl Default for TestConfiguration {
     fn default() -> Self {
         TestConfiguration {
             domain_level: DOMAIN_TGT_LEVEL,
+            ignore_this_field: false,
         }
     }
 }

server/lib/src/valueset/address.rs

@@ -686,7 +686,7 @@ mod tests {
         crate::valueset::scim_json_reflexive(&vs, data);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetEmailAddress>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetEmailAddress>(&vs, &[])
     }
 
     #[test]
@@ -714,6 +714,6 @@ mod tests {
         crate::valueset::scim_json_reflexive(&vs, data);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetAddress>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetAddress>(&vs, &[])
     }
 }

server/lib/src/valueset/bool.rs

@@ -188,6 +188,6 @@ mod tests {
         crate::valueset::scim_json_reflexive(&vs, "true");
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetBool>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetBool>(&vs, &[])
     }
 }

server/lib/src/valueset/certificate.rs

@@ -352,6 +352,6 @@ raBy6edj7W0EIH+yQxkDEwIhAI0nVKaI6duHLAvtKW6CfEQFG6jKg7dyk37YYiRD
         assert_eq!(cert.s256, expect_s256);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetCertificate>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetCertificate>(&vs, &[])
     }
 }

server/lib/src/valueset/cred.rs

@@ -1192,6 +1192,6 @@ mod tests {
         crate::valueset::scim_json_reflexive(&vs, r#""mfa""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetCredentialType>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetCredentialType>(&vs, &[])
     }
 }

server/lib/src/valueset/datetime.rs

@@ -213,6 +213,6 @@ mod tests {
         crate::valueset::scim_json_reflexive(&vs, r#""1970-01-01T19:17:00Z""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetDateTime>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetDateTime>(&vs, &[])
     }
 }

server/lib/src/valueset/image/mod.rs

@@ -532,7 +532,7 @@ mod tests {
             "142dc7984dd548dd5dacfe2ad30f8473e3217e39b3b6c8d17a0cf6e4e24b02e0"
         ]"#;
 
-        crate::valueset::scim_json_reflexive(&vs.clone(), data);
+        crate::valueset::scim_json_reflexive(&vs, data);
     }
     */
 }

server/lib/src/valueset/iname.rs

@@ -226,9 +226,9 @@ mod tests {
     #[test]
     fn test_scim_iname() {
         let vs: ValueSet = ValueSetIname::new("stevo");
-        crate::valueset::scim_json_reflexive(&vs.clone(), r#""stevo""#);
+        crate::valueset::scim_json_reflexive(&vs, r#""stevo""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetIname>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetIname>(&vs, &[])
     }
 }

server/lib/src/valueset/index.rs

@@ -183,9 +183,9 @@ mod tests {
     #[test]
     fn test_scim_index() {
         let vs: ValueSet = ValueSetIndex::new(IndexType::Equality);
-        crate::valueset::scim_json_reflexive(&vs.clone(), r#"["EQUALITY"]"#);
+        crate::valueset::scim_json_reflexive(&vs, r#"["EQUALITY"]"#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetIndex>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetIndex>(&vs, &[])
     }
 }

server/lib/src/valueset/iutf8.rs

@@ -227,9 +227,9 @@ mod tests {
     #[test]
     fn test_scim_iutf8() {
         let vs: ValueSet = ValueSetIutf8::new("lowercase string");
-        crate::valueset::scim_json_reflexive(&vs.clone(), r#""lowercase string""#);
+        crate::valueset::scim_json_reflexive(&vs, r#""lowercase string""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetIutf8>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetIutf8>(&vs, &[])
     }
 }

server/lib/src/valueset/json.rs

@@ -205,9 +205,9 @@ mod tests {
   "{\"pres\":\"class\"}"
 ]
         "#;
-        crate::valueset::scim_json_reflexive(&vs.clone(), data);
+        crate::valueset::scim_json_reflexive(&vs, data);
 
         // Test that we can parse json values into a valueset.
-        // crate::valueset::scim_json_put_reflexive::<ValueSetJsonFilter>(vs, &[])
+        // crate::valueset::scim_json_put_reflexive::<ValueSetJsonFilter>(&vs, &[])
     }
 }

server/lib/src/valueset/mod.rs

@@ -1012,25 +1012,27 @@ pub(crate) fn scim_json_reflexive(vs: &ValueSet, data: &str) {
 #[cfg(test)]
 pub(crate) fn scim_json_reflexive_unresolved(
     write_txn: &mut QueryServerWriteTransaction,
-    vs: ValueSet,
+    vs: &ValueSet,
     data: &str,
 ) {
     let scim_int_value = vs.to_scim_value().unwrap().assume_unresolved();
     let scim_value = write_txn.resolve_scim_interim(scim_int_value).unwrap();
 
-    let strout = serde_json::to_string_pretty(&scim_value).unwrap();
+    let strout = serde_json::to_string_pretty(&scim_value).expect("Failed to serialize");
     eprintln!("{}", strout);
 
-    let json_value: serde_json::Value = serde_json::to_value(&scim_value).unwrap();
+    let json_value: serde_json::Value =
+        serde_json::to_value(&scim_value).expect("Failed to convert to JSON");
 
-    let expect: serde_json::Value = serde_json::from_str(data).unwrap();
+    let expect: serde_json::Value =
+        serde_json::from_str(data).expect("Failed to parse expected JSON");
 
     assert_eq!(json_value, expect);
 }
 
 #[cfg(test)]
 pub(crate) fn scim_json_put_reflexive<T: ValueSetScimPut>(
-    expect_vs: ValueSet,
+    expect_vs: &ValueSet,
     additional_tests: &[(JsonValue, ValueSet)],
 ) {
     let scim_value = expect_vs.to_scim_value().unwrap().assume_resolved();
@@ -1041,7 +1043,7 @@ pub(crate) fn scim_json_put_reflexive<T: ValueSetScimPut>(
     let generic = serde_json::to_value(scim_value).unwrap();
     // Check that we can turn back into a vs from the generic version.
     let vs = T::from_scim_json_put(generic).unwrap().assume_resolved();
-    assert_eq!(&vs, &expect_vs);
+    assert_eq!(&vs, expect_vs);
 
     // For each additional check, assert they work as expected.
     for (jv, expect_vs) in additional_tests {
@@ -1053,7 +1055,7 @@ pub(crate) fn scim_json_put_reflexive<T: ValueSetScimPut>(
 #[cfg(test)]
 pub(crate) fn scim_json_put_reflexive_unresolved<T: ValueSetScimPut>(
     write_txn: &mut QueryServerWriteTransaction,
-    expect_vs: ValueSet,
+    expect_vs: &ValueSet,
     additional_tests: &[(JsonValue, ValueSet)],
 ) {
     let scim_int_value = expect_vs.to_scim_value().unwrap().assume_unresolved();
@@ -1063,7 +1065,7 @@ pub(crate) fn scim_json_put_reflexive_unresolved<T: ValueSetScimPut>(
     // Check that we can turn back into a vs from the generic version.
     let vs_inter = T::from_scim_json_put(generic).unwrap().assume_unresolved();
     let vs = write_txn.resolve_valueset_intermediate(vs_inter).unwrap();
-    assert_eq!(&vs, &expect_vs);
+    assert_eq!(&vs, expect_vs);
 
     // For each additional check, assert they work as expected.
     for (jv, expect_vs) in additional_tests {

server/lib/src/valueset/nsuniqueid.rs

@@ -192,6 +192,6 @@ mod tests {
         crate::valueset::scim_json_reflexive(&vs, r#""3a163ca0-47624620-a18806b7-50c84c86""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetNsUniqueId>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetNsUniqueId>(&vs, &[])
     }
 }

server/lib/src/valueset/oauth.rs

@@ -898,10 +898,10 @@ mod tests {
     fn test_scim_oauth2_scope() {
         let vs: ValueSet = ValueSetOauthScope::new("fully_sick_scope_m8".to_string());
         let data = r#"["fully_sick_scope_m8"]"#;
-        crate::valueset::scim_json_reflexive(&vs.clone(), data);
+        crate::valueset::scim_json_reflexive(&vs, data);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetOauthScope>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetOauthScope>(&vs, &[])
     }
 
     #[qs_test]
@@ -930,12 +930,12 @@ mod tests {
   }
 ]
         "#;
-        crate::valueset::scim_json_reflexive_unresolved(&mut write_txn, vs.clone(), data);
+        crate::valueset::scim_json_reflexive_unresolved(&mut write_txn, &vs, data);
 
         // Test that we can parse json values into a valueset.
         crate::valueset::scim_json_put_reflexive_unresolved::<ValueSetOauthScopeMap>(
             &mut write_txn,
-            vs,
+            &vs,
             &[],
         );
 
@@ -970,12 +970,12 @@ mod tests {
   }
 ]
         "#;
-        crate::valueset::scim_json_reflexive_unresolved(&mut write_txn, vs.clone(), data);
+        crate::valueset::scim_json_reflexive_unresolved(&mut write_txn, &vs, data);
 
         // Test that we can parse json values into a valueset.
         crate::valueset::scim_json_put_reflexive_unresolved::<ValueSetOauthClaimMap>(
             &mut write_txn,
-            vs,
+            &vs,
             &[],
         );
 

server/lib/src/valueset/ssh.rs

@@ -247,9 +247,9 @@ mod tests {
   }
 ]
         "#;
-        crate::valueset::scim_json_reflexive(&vs.clone(), data);
+        crate::valueset::scim_json_reflexive(&vs, data);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetSshKey>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetSshKey>(&vs, &[])
     }
 }

server/lib/src/valueset/syntax.rs

@@ -188,9 +188,9 @@ mod tests {
     #[test]
     fn test_scim_syntax() {
         let vs: ValueSet = ValueSetSyntax::new(SyntaxType::Uuid);
-        crate::valueset::scim_json_reflexive(&vs.clone(), r#""UUID""#);
+        crate::valueset::scim_json_reflexive(&vs, r#""UUID""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetSyntax>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetSyntax>(&vs, &[])
     }
 }

server/lib/src/valueset/uihint.rs

@@ -163,9 +163,9 @@ mod tests {
     #[test]
     fn test_scim_uihint() {
         let vs: ValueSet = ValueSetUiHint::new(UiHint::PosixAccount);
-        crate::valueset::scim_json_reflexive(&vs.clone(), r#"["posixaccount"]"#);
+        crate::valueset::scim_json_reflexive(&vs, r#"["posixaccount"]"#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetUiHint>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetUiHint>(&vs, &[])
     }
 }

server/lib/src/valueset/uint32.rs

@@ -196,9 +196,9 @@ mod tests {
     #[test]
     fn test_scim_uint32() {
         let vs: ValueSet = ValueSetUint32::new(69);
-        crate::valueset::scim_json_reflexive(&vs.clone(), "69");
+        crate::valueset::scim_json_reflexive(&vs, "69");
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetUint32>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetUint32>(&vs, &[])
     }
 }

server/lib/src/valueset/url.rs

@@ -183,9 +183,9 @@ mod tests {
     fn test_scim_url() {
         let u = Url::parse("https://idm.example.com").unwrap();
         let vs: ValueSet = ValueSetUrl::new(u);
-        crate::valueset::scim_json_reflexive(&vs.clone(), r#""https://idm.example.com/""#);
+        crate::valueset::scim_json_reflexive(&vs, r#""https://idm.example.com/""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetUrl>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetUrl>(&vs, &[])
     }
 }

server/lib/src/valueset/utf8.rs

@@ -246,9 +246,9 @@ mod tests {
     fn test_scim_utf8() {
         let vs: ValueSet = ValueSetUtf8::new("Test".to_string());
         // Test that the output json matches some known str
-        crate::valueset::scim_json_reflexive(&vs.clone(), r#""Test""#);
+        crate::valueset::scim_json_reflexive(&vs, r#""Test""#);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetUtf8>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetUtf8>(&vs, &[])
     }
 }

server/lib/src/valueset/uuid.rs

@@ -422,10 +422,10 @@ mod tests {
 
         let data = r#""4d21d04a-dc0e-42eb-b850-34dd180b107f""#;
 
-        crate::valueset::scim_json_reflexive(&vs.clone(), data);
+        crate::valueset::scim_json_reflexive(&vs, data);
 
         // Test that we can parse json values into a valueset.
-        crate::valueset::scim_json_put_reflexive::<ValueSetUuid>(vs, &[])
+        crate::valueset::scim_json_put_reflexive::<ValueSetUuid>(&vs, &[])
     }
 
     #[qs_test]
@@ -449,12 +449,12 @@ mod tests {
 
         let data = r#"[{"uuid": "4d21d04a-dc0e-42eb-b850-34dd180b107f", "value": "testperson1@example.com"}]"#;
 
-        crate::valueset::scim_json_reflexive_unresolved(&mut write_txn, vs.clone(), data);
+        crate::valueset::scim_json_reflexive_unresolved(&mut write_txn, &vs, data);
 
         // Test that we can parse json values into a valueset.
         crate::valueset::scim_json_put_reflexive_unresolved::<ValueSetRefer>(
             &mut write_txn,
-            vs,
+            &vs,
             &[],
         );