Clean up test noise now that I know where I need to place updates

Author: scouten-adobe

c2pa_c_ffi/src/c_api.rs

@@ -463,7 +463,8 @@ pub unsafe extern "C" fn c2pa_free_string_array(ptr: *const *const c_char, count
 
 // Run CAWG post-validation - this is async and requires a runtime.
 fn post_validate(result: Result<C2paReader, c2pa::Error>) -> Result<C2paReader, c2pa::Error> {
-    if true {
+    if false {
+        // CONSIDER BEFORE MERGING ...
         todo!("Remove me?");
     }
 

c2pa_c_ffi/src/json_api.rs

@@ -24,7 +24,8 @@ use crate::{Error, Result, SignerInfo};
 pub fn read_file(path: &str, data_dir: Option<String>) -> Result<String> {
     let mut reader = Reader::from_file(path).map_err(Error::from_c2pa_error)?;
     let runtime = Runtime::new().map_err(|e| Error::Other(e.to_string()))?;
-    if true {
+    if false {
+        // CONSIDER BEFORE MERGING ...
         todo!("Remove post_validate_async here?");
     }
     runtime

cli/src/main.rs

@@ -574,7 +574,8 @@ fn verify_fragmented(init_pattern: &Path, frag_pattern: &Path) -> Result<Vec<Rea
 
 // run cawg validation if supported
 fn validate_cawg(reader: &mut Reader) -> Result<()> {
-    if true {
+    if false {
+        // CONSIDER BEFORE MERGING ...
         todo!("Remove me?");
     }
     #[cfg(not(target_os = "wasi"))]

sdk/examples/cawg_identity.rs

@@ -29,7 +29,6 @@ mod cawg {
         crypto::raw_signature,
         identity::{
             builder::{AsyncIdentityAssertionBuilder, AsyncIdentityAssertionSigner},
-            validator::CawgValidator,
             x509::AsyncX509CredentialHolder,
         },
         AsyncSigner, Builder, Reader, SigningAlg,

sdk/src/identity/x509/x509_credential_holder.rs

@@ -88,7 +88,7 @@ mod tests {
             x509::{X509CredentialHolder, X509SignatureVerifier},
             IdentityAssertion,
         },
-        status_tracker::StatusTracker,
+        status_tracker::{LogKind, StatusTracker},
         Builder, Reader, SigningAlg,
     };
 
@@ -134,7 +134,7 @@ mod tests {
         // Read back the Manifest that was generated.
         dest.rewind().unwrap();
 
-        let manifest_store = Reader::from_stream(format, &mut dest).unwrap();
+        let manifest_store = Reader::from_stream_async(format, &mut dest).await.unwrap();
         assert_eq!(manifest_store.validation_status(), None);
 
         let validation_results = manifest_store.validation_results().unwrap();
@@ -153,9 +153,9 @@ mod tests {
         let ia_success = ia_success_codes.next().unwrap();
         dbg!(&ia_success);
 
-        if true {
-            panic!("Look for identity assertion success codes");
-        }
+        assert_eq!(ia_success.code(), "signingCredential.trusted");
+        assert!(ia_success.url().unwrap().ends_with("cawg.identity"));
+        assert_eq!(ia_success.kind(), &LogKind::Success);
 
         let manifest = manifest_store.active_manifest().unwrap();
         let mut st = StatusTracker::default();

sdk/src/reader.rs

@@ -136,17 +136,19 @@ impl Reader {
             Store::from_stream_async(format, &mut stream, verify, &mut validation_log).await
         }?;
 
-        let /* mut */ result = Self::from_store(store, &validation_log)?;
+        #[allow(unused_mut)] // TEMPORARY until I figure out the synchronous path.
+        let mut result = Self::from_store(store, &validation_log)?;
         if _sync {
             // TO DO: Figure out how to handle synchronous validation with
             // identity assertions? Just report an error (needs async)?
             if false {
                 todo!("Add identity assertion validation here");
             }
         } else {
-            if true {
-                todo!("Add identity assertion validation here");
-            }
+            use crate::identity::validator::CawgValidator;
+            result
+                .post_validate_internal_async(&CawgValidator {})
+                .await?;
         }
 
         Ok(result)
@@ -752,9 +754,24 @@ impl Reader {
         validator: &impl AsyncPostValidator
     ))]
     pub fn post_validate(&mut self, validator: &impl PostValidator) -> Result<()> {
-        if true {
-            todo!("Remove me");
+        if false {
+            // CONSIDER BEFORE MERGING ...
+            todo!("Remove me?");
+        }
+
+        if _sync {
+            self.post_validate_internal(validator)
+        } else {
+            self.post_validate_internal_async(validator).await
         }
+    }
+
+    #[async_generic(async_signature(
+        &mut self,
+        validator: &impl AsyncPostValidator
+    ))]
+    fn post_validate_internal(&mut self, validator: &impl PostValidator) -> Result<()> {
+        // TEMPORARY: Make this available while I sort out new code path.
         let mut validation_log = StatusTracker::default();
         let mut validation_results = self.validation_results.take().unwrap_or_default();
         let mut assertion_values = HashMap::new();
@@ -1017,8 +1034,9 @@ pub mod tests {
 
     #[test]
     fn test_reader_post_validate() -> Result<()> {
-        if true {
-            todo!("Remove me");
+        if false {
+            // CONSIDER BEFORE MERGING ...
+            todo!("Remove me?");
         }
         use crate::{log_item, status_tracker::StatusTracker};