Cleanup of validation API

oxisto · oxisto · commit 7f2247435b52 · 2025-11-10T22:04:13.000+01:00
diff --git a/csaf-rs/src/csaf/validation.rs b/csaf-rs/src/csaf/validation.rs
@@ -20,6 +20,20 @@ impl std::fmt::Display for ValidationError {
     }
 }
 
+/// Result of a CSAF validation
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ValidationResult {
+    /// Whether the validation was successful (no errors)
+    pub success: bool,
+    /// The detected CSAF version
+    pub version: String,
+    /// List of validation errors (empty if successful)
+    pub errors: Vec<ValidationError>,
+    /// The validation preset that was used
+    pub preset: ValidationPreset,
+}
+
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ValidationPreset {
@@ -110,3 +124,70 @@ pub fn validate_by_test<VersionedDocument>(
         println!("Test with ID {} is missing implementation", test_id);
     }
 }
+
+/// Collect validation errors for a given preset without printing
+pub fn collect_validation_errors<VersionedDocument>(
+    target: &impl Validatable<VersionedDocument>,
+    preset: &ValidationPreset,
+) -> Vec<ValidationError> {
+    let mut errors = Vec::new();
+
+    if let Some(test_ids) = target.presets().get(preset) {
+        let tests = target.tests();
+        
+        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
+}
+
+/// 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,
+    }
+}
+
+/// 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>(
+    target: &impl Validatable<VersionedDocument>,
+    version: &str,
+    preset: ValidationPreset,
+) {
+    let result = create_validation_result(target, version, preset);
+    print_validation_result(&result);
+}
diff --git a/csaf-rs/src/wasm.rs b/csaf-rs/src/wasm.rs
@@ -3,25 +3,10 @@
 //! This module provides WebAssembly bindings for validating CSAF documents in the browser.
 
 use wasm_bindgen::prelude::*;
-use serde::{Deserialize, Serialize};
-use crate::csaf::validation::{ValidationError, ValidationPreset, Validatable};
+use crate::csaf::validation::{ValidationResult, ValidationPreset, create_validation_result};
 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;
 
-/// Result of a CSAF validation
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ValidationResult {
-    /// Whether the validation was successful (no errors)
-    pub success: bool,
-    /// The detected CSAF version
-    pub version: String,
-    /// List of validation errors (empty if successful)
-    pub errors: Vec<ValidationError>,
-    /// The validation preset that was used
-    pub preset: ValidationPreset,
-}
-
 /// Initialize panic hook for better error messages in the browser console
 #[wasm_bindgen(start)]
 pub fn init() {
@@ -76,82 +61,18 @@ pub fn validate_csaf(json_str: &str, preset_str: &str) -> Result<JsValue, JsValu
 
 /// Validate a CSAF 2.0 document
 fn validate_2_0(json_str: &str, preset: ValidationPreset) -> Result<ValidationResult, String> {
-    // Load the document
     let document = load_document_from_str_2_0(json_str)
         .map_err(|e| format!("Failed to load CSAF 2.0 document: {}", e))?;
-
-    // Collect errors by temporarily capturing output
-    let errors = collect_validation_errors_2_0(&document, preset.clone());
-
-    Ok(ValidationResult {
-        success: errors.is_empty(),
-        version: "2.0".to_string(),
-        errors,
-        preset,
-    })
+    
+    Ok(create_validation_result(&document, "2.0", preset))
 }
 
 /// Validate a CSAF 2.1 document
 fn validate_2_1(json_str: &str, preset: ValidationPreset) -> Result<ValidationResult, String> {
-    // Load the document
     let document = load_document_from_str_2_1(json_str)
         .map_err(|e| format!("Failed to load CSAF 2.1 document: {}", e))?;
-
-    // Collect errors by temporarily capturing output
-    let errors = collect_validation_errors_2_1(&document, preset.clone());
-
-    Ok(ValidationResult {
-        success: errors.is_empty(),
-        version: "2.1".to_string(),
-        errors,
-        preset,
-    })
-}
-
-/// Helper to collect validation errors from CSAF 2.0 validation
-fn collect_validation_errors_2_0(
-    target: &impl Validatable<crate::csaf::csaf2_0::schema::CommonSecurityAdvisoryFramework>,
-    preset: ValidationPreset,
-) -> Vec<ValidationError> {
-    let mut errors = Vec::new();
-
-    // Get tests for the preset
-    if let Some(test_ids) = target.presets().get(&preset) {
-        let tests = target.tests();
-        
-        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
-}
-
-/// Helper to collect validation errors from CSAF 2.1 validation
-fn collect_validation_errors_2_1(
-    target: &impl Validatable<crate::csaf::csaf2_1::schema::CommonSecurityAdvisoryFramework>,
-    preset: ValidationPreset,
-) -> Vec<ValidationError> {
-    let mut errors = Vec::new();
-
-    // Get tests for the preset
-    if let Some(test_ids) = target.presets().get(&preset) {
-        let tests = target.tests();
-        
-        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
+    
+    Ok(create_validation_result(&document, "2.1", preset))
 }
 
 #[cfg(test)]
diff --git a/csaf-validator/src/main.rs b/csaf-validator/src/main.rs
@@ -2,7 +2,7 @@ use std::str::FromStr;
 use anyhow::{bail, Result};
 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::{validate_by_preset, validate_by_test, Validatable, ValidationPreset};
+use csaf_rs::csaf::validation::{create_validation_result, print_validation_result, validate_by_test, ValidationPreset};
 use clap::Parser;
 
 #[cfg(feature = "web")]
@@ -74,18 +74,20 @@ fn main() -> Result<()> {
 fn validate_file(path: &str, args: &Args) -> Result<()> {
     match args.csaf_version.as_str() {
         "2.0" => {
-            process_document(load_document_2_0(path)?, args)
+            let document = load_document_2_0(path)?;
+            process_document(document, "2.0", args)
         }
         "2.1" => {
-            process_document(load_document_2_1(path)?, args)
+            let document = load_document_2_1(path)?;
+            process_document(document, "2.1", args)
         }
         _ => bail!(format!("Invalid CSAF version: {}", args.csaf_version)),
     }
 }
 
-fn process_document<T>(document: T, args: &Args) -> Result<()>
+fn process_document<T>(document: T, version: &str, args: &Args) -> Result<()>
 where
-    T: Validatable<T>,
+    T: csaf_rs::csaf::validation::Validatable<T>,
 {
     if !args.test_id.is_empty() {
         for test_id in &args.test_id {
@@ -94,11 +96,11 @@ where
         }
         Ok(())
     } else {
-        let preset = match ValidationPreset::from_str(args.preset.as_str()) {
-            Ok(preset) => preset,
-            Err(_) => bail!(format!("Invalid validation preset: {}", args.preset)),
-        };
-        validate_by_preset(&document, preset);
+        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(())
     }
 }
diff --git a/csaf-validator/src/web/mod.rs b/csaf-validator/src/web/mod.rs
@@ -21,9 +21,9 @@ struct StaticAssets;
 pub async fn start_server(host: &str, port: u16) -> anyhow::Result<()> {
     let addr: SocketAddr = format!("{}:{}", host, port).parse()?;
 
-    // Build the router - serves all static files
+    // Build the router - serve all static files with fallback to index.html
     let app = Router::new()
-        .route("/", get(index_handler))
+        .route("/", get(static_handler))
         .route("/*path", get(static_handler));
 
     println!("\n🚀 CSAF Validator Web UI starting...");
@@ -38,15 +38,15 @@ pub async fn start_server(host: &str, port: u16) -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Handler for the index page
-async fn index_handler() -> impl IntoResponse {
-    static_handler(axum::extract::Path("index.html".to_string())).await
-}
-
 /// Handler for all static files (HTML, JS, CSS, WASM, etc.)
-async fn static_handler(axum::extract::Path(path): axum::extract::Path<String>) -> Response {
-    // Remove leading slash if present
+/// Defaults to index.html for root path
+async fn static_handler(path: Option<axum::extract::Path<String>>) -> Response {
+    let path = path
+        .map(|p| p.0)
+        .unwrap_or_else(|| "index.html".to_string());
+    
     let path = path.trim_start_matches('/');
+    let path = if path.is_empty() { "index.html" } else { path };
     
     match StaticAssets::get(path) {
         Some(content) => {
