Major cleanup of validation API

Author: oxisto

csaf-rs/src/csaf/validation.rs

@@ -1,7 +1,7 @@
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fmt::{Display, Formatter};
 use std::str::FromStr;
-use serde::{Serialize, Deserialize};
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
 pub struct ValidationError {
@@ -20,6 +20,18 @@ impl std::fmt::Display for ValidationError {
     }
 }
 
+/// Result of executing a single test
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TestResult {
+    /// The test ID that was executed
+    pub test_id: String,
+    /// Whether the test passed
+    pub success: bool,
+    /// The errors if the test failed (empty if successful)
+    pub errors: Vec<ValidationError>,
+}
+
 /// Result of a CSAF validation
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -32,6 +44,8 @@ pub struct ValidationResult {
     pub errors: Vec<ValidationError>,
     /// The validation preset that was used
     pub preset: ValidationPreset,
+    /// Individual test results with execution details
+    pub test_results: Vec<TestResult>,
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
@@ -66,11 +80,19 @@ impl Display for ValidationPreset {
 }
 
 pub trait Validate {
-    /// Validates this object according to a validation preset
-    fn validate_preset(&'static self, preset: ValidationPreset);
-
-    /// Validates this object according to a specific test ID.
-    fn validate_by_test(&self, version: &str);
+    /// Validates this object according to
+    fn validate_by_test<VersionedDocument>(&self, test_id: &str) -> TestResult;
+
+    /// Validates this object according to specific test IDs and returns detailed results
+    fn validate_tests(
+        &self,
+        version: &str,
+        preset: ValidationPreset,
+        test_ids: &[&str],
+    ) -> ValidationResult;
+
+    /// Validates this object according to a validation preset and returns detailed results
+    fn validate_preset(&self, version: &str, preset: ValidationPreset) -> ValidationResult;
 }
 
 pub type Test<VersionedDocument> = fn(&VersionedDocument) -> Result<(), ValidationError>;
@@ -90,104 +112,85 @@ pub trait Validatable<VersionedDocument> {
     fn doc(&self) -> &VersionedDocument;
 }
 
-/// Executes all tests of the specified [preset] against the [target]
-/// (which is of type [VersionedDocument], e.g. a CSAF 2.0 document).
-pub fn validate_by_preset<VersionedDocument>(
-    target: &impl Validatable<VersionedDocument>,
-    preset: ValidationPreset,
-) {
-    println!("Validating document with {:?} preset... \n", preset);
-
-    // Loop through tests
-    if let Some(tests) = target.presets().get(&preset) {
-        for test_id in tests {
-            println!("Executing Test {}... ", test_id);
-            validate_by_test(target, test_id);
-
-            println!()
-        }
-    } else {
-        println!("No tests found for preset")
-    }
-}
-
+/// Execute a single test and return the test result.
+///
+/// This function will check, whether the test_id exists in the Validatable's
+/// tests. If it does, it will execute the test function and return the result.
+/// If not, it will return a TestResult indicating that the test was not found.
 pub fn validate_by_test<VersionedDocument>(
     target: &impl Validatable<VersionedDocument>,
     test_id: &str,
-) {
-    if let Some(test_fn) = target.tests().get(test_id) {
-        let _ = match test_fn(target.doc()) {
-            Ok(()) => println!("> Test Success"),
-            Err(e) => println!("> Error: {}", e),
-        };
+) -> TestResult {
+    // Fetch tests from the validatable
+    let tests = target.tests();
+
+    // Try to find and execute the test specified by the test_id
+    if let Some(test_fn) = tests.get(test_id) {
+        match test_fn(target.doc()) {
+            Ok(()) => TestResult {
+                test_id: test_id.to_string(),
+                success: true,
+                errors: vec![],
+            },
+            Err(error) => TestResult {
+                test_id: test_id.to_string(),
+                success: false,
+                errors: vec![error],
+            },
+        }
     } else {
-        println!("Test with ID {} is missing implementation", test_id);
+        let error = ValidationError {
+            message: format!("Test '{}' not found", test_id),
+            instance_path: "".to_string(),
+        };
+        TestResult {
+            test_id: test_id.to_string(),
+            success: false,
+            errors: vec![error],
+        }
     }
 }
 
-/// Collect validation errors for a given preset without printing
-pub fn collect_validation_errors<VersionedDocument>(
+/// Validate document with specific tests and return detailed results.
+pub fn validate_by_tests<VersionedDocument>(
     target: &impl Validatable<VersionedDocument>,
-    preset: &ValidationPreset,
-) -> Vec<ValidationError> {
+    version: &str,
+    preset: ValidationPreset,
+    test_ids: &[&str],
+) -> ValidationResult {
     let mut errors = Vec::new();
+    let mut test_results = Vec::new();
 
-    if let Some(test_ids) = target.presets().get(preset) {
-        let tests = target.tests();
+    // Loop through tests and gather all results and errors
+    for test_id in test_ids {
+        let test_result = validate_by_test(target, test_id);
 
-        for test_id in test_ids {
-            if let Some(test_fn) = tests.get(test_id) {
-                if let Err(error) = test_fn(target.doc()) {
-                    errors.push(error);
-                }
-            }
-        }
+        errors.extend(test_result.errors.iter().cloned());
+        test_results.push(test_result);
     }
 
-    errors
-}
-
-/// Create a validation result from a validatable document
-pub fn create_validation_result<VersionedDocument>(
-    target: &impl Validatable<VersionedDocument>,
-    version: &str,
-    preset: ValidationPreset,
-) -> ValidationResult {
-    let errors = collect_validation_errors(target, &preset);
-    
     ValidationResult {
         success: errors.is_empty(),
         version: version.to_string(),
         errors,
         preset,
+        test_results,
     }
 }
 
-/// Print a validation result to stdout (for CLI use)
-pub fn print_validation_result(result: &ValidationResult) {
-    println!("Validating document with {:?} preset... \n", result.preset);
-    
-    if result.success {
-        println!("✅ Validation passed! No errors found.");
-        println!("   CSAF Version: {}", result.version);
-        println!();
-    } else {
-        println!("❌ Validation failed with {} error(s):", result.errors.len());
-        println!("   CSAF Version: {}", result.version);
-        println!();
-        for error in &result.errors {
-            println!("  • {} (at {})", error.message, error.instance_path);
-        }
-        println!();
-    }
-}
-
-/// Validate and print results - convenience function for CLI use
-pub fn validate_and_print<VersionedDocument>(
+/// Validate document with a preset and return detailed results.
+pub fn validate_by_preset<VersionedDocument>(
     target: &impl Validatable<VersionedDocument>,
     version: &str,
     preset: ValidationPreset,
-) {
-    let result = create_validation_result(target, version, preset);
-    print_validation_result(&result);
+) -> ValidationResult {
+    // Retrieve the test IDs for the given preset
+    let test_ids: Vec<&str> = target
+        .presets()
+        .get(&preset)
+        .map(|ids| ids.iter().copied().collect())
+        .unwrap_or_default();
+
+    // Forward them to validate_by_tests
+    validate_by_tests(target, version, preset, &test_ids)
 }

csaf-rs/src/wasm.rs

@@ -3,7 +3,7 @@
 //! This module provides WebAssembly bindings for validating CSAF documents in the browser.
 
 use wasm_bindgen::prelude::*;
-use crate::csaf::validation::{ValidationResult, ValidationPreset, create_validation_result};
+use crate::csaf::validation::{ValidationResult, ValidationPreset, validate_by_preset};
 use crate::csaf::csaf2_0::loader::load_document_from_str as load_document_from_str_2_0;
 use crate::csaf::csaf2_1::loader::load_document_from_str as load_document_from_str_2_1;
 
@@ -64,15 +64,15 @@ fn validate_2_0(json_str: &str, preset: ValidationPreset) -> Result<ValidationRe
     let document = load_document_from_str_2_0(json_str)
         .map_err(|e| format!("Failed to load CSAF 2.0 document: {}", e))?;
 
-    Ok(create_validation_result(&document, "2.0", preset))
+    Ok(validate_by_preset(&document, "2.0", preset))
 }
 
 /// Validate a CSAF 2.1 document
 fn validate_2_1(json_str: &str, preset: ValidationPreset) -> Result<ValidationResult, String> {
     let document = load_document_from_str_2_1(json_str)
         .map_err(|e| format!("Failed to load CSAF 2.1 document: {}", e))?;
 
-    Ok(create_validation_result(&document, "2.1", preset))
+    Ok(validate_by_preset(&document, "2.1", preset))
 }
 
 #[cfg(test)]
@@ -86,6 +86,7 @@ mod tests {
             version: "2.0".to_string(),
             errors: vec![],
             preset: ValidationPreset::Basic,
+            test_results: vec![],
         };
 
         let json = serde_json::to_string(&result).unwrap();

csaf-validator/src/main.rs

@@ -1,9 +1,11 @@
-use std::str::FromStr;
 use anyhow::{bail, Result};
+use clap::Parser;
 use csaf_rs::csaf::csaf2_0::loader::load_document as load_document_2_0;
 use csaf_rs::csaf::csaf2_1::loader::load_document as load_document_2_1;
-use csaf_rs::csaf::validation::{create_validation_result, print_validation_result, validate_by_test, ValidationPreset};
-use clap::Parser;
+use csaf_rs::csaf::validation::{
+    validate_by_preset, validate_by_tests, ValidationPreset, ValidationResult,
+};
+use std::str::FromStr;
 
 #[cfg(feature = "web")]
 mod web;
@@ -55,7 +57,9 @@ async fn main() -> Result<()> {
     }
 
     // Otherwise, validate a file
-    let path = args.path.as_ref()
+    let path = args
+        .path
+        .as_ref()
         .ok_or_else(|| anyhow::anyhow!("Path argument is required when not using --web"))?;
 
     validate_file(path, &args)
@@ -65,42 +69,84 @@ async fn main() -> Result<()> {
 fn main() -> Result<()> {
     let args = Args::parse();
 
-    let path = args.path.as_ref()
+    let path = args
+        .path
+        .as_ref()
         .ok_or_else(|| anyhow::anyhow!("Path argument is required"))?;
 
     validate_file(path, &args)
 }
 
+/// Try to validate a file as a CSAF document based on the specified version.
 fn validate_file(path: &str, args: &Args) -> Result<()> {
     match args.csaf_version.as_str() {
         "2.0" => {
             let document = load_document_2_0(path)?;
-            process_document(document, "2.0", args)
+            validate_document(document, "2.0", args)
         }
         "2.1" => {
             let document = load_document_2_1(path)?;
-            process_document(document, "2.1", args)
+            validate_document(document, "2.1", args)
         }
         _ => bail!(format!("Invalid CSAF version: {}", args.csaf_version)),
     }
 }
 
-fn process_document<T>(document: T, version: &str, args: &Args) -> Result<()>
+/// Validate a CSAF document of the specified version with the provided arguments.
+///
+/// This prints the results of the tests on stdout.
+fn validate_document<T>(document: T, version: &str, args: &Args) -> Result<()>
 where
     T: csaf_rs::csaf::validation::Validatable<T>,
 {
-    if !args.test_id.is_empty() {
-        for test_id in &args.test_id {
-            println!("\nExecuting Test {}... ", test_id);
-            validate_by_test(&document, test_id.as_str());
+    let preset = ValidationPreset::from_str(args.preset.as_str())
+        .map_err(|_| anyhow::anyhow!("Invalid validation preset: {}", args.preset))?;
+
+    let result = if !args.test_id.is_empty() {
+        // Individual test validation
+        let test_ids: Vec<&str> = args.test_id.iter().map(|s| s.as_str()).collect();
+        validate_by_tests(&document, version, preset, &test_ids)
+    } else {
+        // Preset validation
+        validate_by_preset(&document, version, preset)
+    };
+
+    print_validation_result(&result);
+    Ok(())
+}
+
+/// Print a validation result to stdout (for CLI use)
+pub fn print_validation_result(result: &ValidationResult) {
+    println!("CSAF Version: {}", result.version);
+    println!("Validating document with {:?} preset...\n", result.preset);
+
+    // Print individual test results
+    for test_result in &result.test_results {
+        if test_result.success {
+            println!("Executing Test {}... ✅ Success", test_result.test_id);
+        } else if let Some(error) = test_result.errors.first() {
+            if error.message.contains("not found") {
+                println!(
+                    "Executing Test {}... ⚠️  Test not found",
+                    test_result.test_id
+                );
+            } else {
+                println!(
+                    "Executing Test {}... ❌ Error: {}",
+                    test_result.test_id, error.message
+                );
+            }
         }
-        Ok(())
+    }
+
+    // Print summary
+    println!();
+    if result.success {
+        println!("✅ Validation passed! No errors found.\n");
     } else {
-        let preset = ValidationPreset::from_str(args.preset.as_str())
-            .map_err(|_| anyhow::anyhow!("Invalid validation preset: {}", args.preset))?;
-        
-        let result = create_validation_result(&document, version, preset);
-        print_validation_result(&result);
-        Ok(())
+        println!(
+            "❌ Validation failed with {} error(s)\n",
+            result.errors.len()
+        );
     }
 }