fix: correct tests

Author: bordumb

crates/auths-cli/tests/cases/verify.rs

@@ -15,18 +15,16 @@ fn create_signed_attestation(
     device_kp: &ring::signature::Ed25519KeyPair,
 ) -> Attestation {
     let device_pk: [u8; 32] = device_kp.public_key().as_ref().try_into().unwrap();
+    let issuer_pk: [u8; 32] = issuer_kp.public_key().as_ref().try_into().unwrap();
+
+    let device_did = DeviceDID::from_ed25519(&device_pk);
+    let issuer_did = DeviceDID::from_ed25519(&issuer_pk);
 
     let mut att = Attestation {
         version: 1,
         rid: ResourceId::new("test-rid"),
-        issuer: CanonicalDid::new_unchecked(format!(
-            "did:key:{}",
-            hex::encode(issuer_kp.public_key().as_ref())
-        )),
-        subject: DeviceDID::new_unchecked(format!(
-            "did:key:{}",
-            hex::encode(device_kp.public_key().as_ref())
-        )),
+        issuer: CanonicalDid::from(issuer_did),
+        subject: device_did,
         device_public_key: Ed25519PublicKey::from_bytes(device_pk),
         identity_signature: Ed25519Signature::empty(),
         device_signature: Ed25519Signature::empty(),

crates/auths-id/src/keri/cache.rs

@@ -363,6 +363,8 @@ mod tests {
     use crate::keri::Prefix;
     use tempfile::TempDir;
 
+    const VALID_OID: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+
     fn create_test_state() -> KeyState {
         KeyState::from_inception(
             Prefix::new_unchecked("ETestPrefix".to_string()),
@@ -400,15 +402,7 @@ mod tests {
         let tip_said = "ELatestSaid";
 
         // Write cache
-        write_kel_cache(
-            dir.path(),
-            did,
-            &state,
-            tip_said,
-            "abc123def456",
-            Utc::now(),
-        )
-        .unwrap();
+        write_kel_cache(dir.path(), did, &state, tip_said, VALID_OID, Utc::now()).unwrap();
 
         // Read it back
         let loaded = try_load_cached_state(dir.path(), did, tip_said);
@@ -425,7 +419,7 @@ mod tests {
         let state = create_test_state();
 
         // Write cache with one SAID
-        write_kel_cache(dir.path(), did, &state, "EOldSaid", "commit123", Utc::now()).unwrap();
+        write_kel_cache(dir.path(), did, &state, "EOldSaid", VALID_OID, Utc::now()).unwrap();
 
         // Try to load with different SAID - should return None
         let result = try_load_cached_state(dir.path(), did, "ENewSaid");
@@ -444,15 +438,7 @@ mod tests {
         let tip_said = "ESaid";
 
         // Write cache
-        write_kel_cache(
-            dir.path(),
-            did,
-            &state,
-            tip_said,
-            "abc123def456",
-            Utc::now(),
-        )
-        .unwrap();
+        write_kel_cache(dir.path(), did, &state, tip_said, VALID_OID, Utc::now()).unwrap();
 
         // Manually corrupt the cache by writing wrong DID
         let path = cache_path_for_did(dir.path(), did);
@@ -496,15 +482,7 @@ mod tests {
         let tip_said = "ESaid";
 
         // Write cache
-        write_kel_cache(
-            dir.path(),
-            did,
-            &state,
-            tip_said,
-            "abc123def456",
-            Utc::now(),
-        )
-        .unwrap();
+        write_kel_cache(dir.path(), did, &state, tip_said, VALID_OID, Utc::now()).unwrap();
 
         // Manually change version
         let path = cache_path_for_did(dir.path(), did);
@@ -525,7 +503,7 @@ mod tests {
         let state = create_test_state();
 
         // Write and verify cache exists
-        write_kel_cache(dir.path(), did, &state, "ESaid", "commit123", Utc::now()).unwrap();
+        write_kel_cache(dir.path(), did, &state, "ESaid", VALID_OID, Utc::now()).unwrap();
         assert!(try_load_cached_state(dir.path(), did, "ESaid").is_some());
 
         // Invalidate
@@ -554,7 +532,7 @@ mod tests {
             "did:keri:ETest1",
             &state,
             "ESaid1",
-            "commit1",
+            VALID_OID,
             Utc::now(),
         )
         .unwrap();
@@ -563,7 +541,7 @@ mod tests {
             "did:keri:ETest2",
             &state,
             "ESaid2",
-            "commit2",
+            VALID_OID,
             Utc::now(),
         )
         .unwrap();
@@ -587,7 +565,7 @@ mod tests {
             "did:keri:EClear1",
             &state,
             "ESaid",
-            "commit1",
+            VALID_OID,
             Utc::now(),
         )
         .unwrap();
@@ -596,7 +574,7 @@ mod tests {
             "did:keri:EClear2",
             &state,
             "ESaid",
-            "commit2",
+            VALID_OID,
             Utc::now(),
         )
         .unwrap();
@@ -617,15 +595,7 @@ mod tests {
         let state = create_test_state();
         let tip_said = "ESaid";
 
-        write_kel_cache(
-            dir.path(),
-            did,
-            &state,
-            tip_said,
-            "abc123def456",
-            Utc::now(),
-        )
-        .unwrap();
+        write_kel_cache(dir.path(), did, &state, tip_said, VALID_OID, Utc::now()).unwrap();
 
         let inspected = inspect_cache(dir.path(), did).unwrap();
         assert!(inspected.is_some());

crates/auths-sdk/src/workflows/allowed_signers.rs

@@ -616,7 +616,7 @@ mod tests {
     #[test]
     fn error_codes_and_suggestions() {
         let err = AllowedSignersError::InvalidEmail("test".to_string());
-        assert_eq!(err.error_code(), "AUTHS_INVALID_EMAIL");
+        assert_eq!(err.error_code(), "AUTHS-E5801");
         assert!(err.suggestion().is_some());
     }
 }

crates/auths-verifier/tests/cases/ssh_sig.rs

@@ -42,19 +42,19 @@ fn error_codes_are_correct() {
     use auths_verifier::error::AuthsErrorInfo;
 
     let err = CommitVerificationError::UnsignedCommit;
-    assert_eq!(err.error_code(), "AUTHS_UNSIGNED_COMMIT");
+    assert_eq!(err.error_code(), "AUTHS-E2101");
 
     let err = CommitVerificationError::GpgNotSupported;
-    assert_eq!(err.error_code(), "AUTHS_GPG_NOT_SUPPORTED");
+    assert_eq!(err.error_code(), "AUTHS-E2102");
 
     let err = CommitVerificationError::UnknownSigner;
-    assert_eq!(err.error_code(), "AUTHS_UNKNOWN_SIGNER");
+    assert_eq!(err.error_code(), "AUTHS-E2108");
 
     let err = CommitVerificationError::SignatureInvalid;
-    assert_eq!(err.error_code(), "AUTHS_SIGNATURE_INVALID");
+    assert_eq!(err.error_code(), "AUTHS-E2107");
 
     let err = CommitVerificationError::UnsupportedKeyType {
         found: "ssh-rsa".into(),
     };
-    assert_eq!(err.error_code(), "AUTHS_UNSUPPORTED_KEY_TYPE");
+    assert_eq!(err.error_code(), "AUTHS-E2104");
 }