@feltdb/core 0.5.7 → 0.6.0

package/dist/create/server-source/crates/feltdb-server/src/certification_harness.rs

@@ -0,0 +1,528 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// Test category for certification harness.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash)]
+#[serde(rename_all = "lowercase")]
+pub enum TestCategory {
+    Authentication,
+    Authorization,
+    Pagination,
+    Transactions,
+    Operations,
+    Diagnostics,
+}
+
+impl TestCategory {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            TestCategory::Authentication => "authentication",
+            TestCategory::Authorization => "authorization",
+            TestCategory::Pagination => "pagination",
+            TestCategory::Transactions => "transactions",
+            TestCategory::Operations => "operations",
+            TestCategory::Diagnostics => "diagnostics",
+        }
+    }
+}
+
+/// Environment for test execution.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum TestEnvironment {
+    Local,
+    ManagedStaging,
+    ManagedProduction,
+}
+
+impl TestEnvironment {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            TestEnvironment::Local => "local",
+            TestEnvironment::ManagedStaging => "managed_staging",
+            TestEnvironment::ManagedProduction => "managed_production",
+        }
+    }
+}
+
+/// Test result status.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum TestStatus {
+    Passed,
+    Failed,
+    Skipped,
+}
+
+/// Individual test result.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestResult {
+    pub test_id: String,
+    pub category: TestCategory,
+    pub name: String,
+    pub status: TestStatus,
+    pub error_message: Option<String>,
+    pub duration_ms: u64,
+    pub timestamp: u64,
+}
+
+impl TestResult {
+    pub fn new(test_id: String, category: TestCategory, name: String) -> Self {
+        Self {
+            test_id,
+            category,
+            name,
+            status: TestStatus::Passed,
+            error_message: None,
+            duration_ms: 0,
+            timestamp: now(),
+        }
+    }
+
+    pub fn passed(mut self, duration_ms: u64) -> Self {
+        self.status = TestStatus::Passed;
+        self.duration_ms = duration_ms;
+        self
+    }
+
+    pub fn failed(mut self, error: String, duration_ms: u64) -> Self {
+        self.status = TestStatus::Failed;
+        self.error_message = Some(error);
+        self.duration_ms = duration_ms;
+        self
+    }
+
+    pub fn skipped(mut self, reason: String, duration_ms: u64) -> Self {
+        self.status = TestStatus::Skipped;
+        self.error_message = Some(reason);
+        self.duration_ms = duration_ms;
+        self
+    }
+
+    pub fn is_passing(&self) -> bool {
+        self.status == TestStatus::Passed
+    }
+}
+
+/// Certification harness report.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CertificationReport {
+    /// Report ID (unique per run).
+    pub report_id: String,
+
+    /// Environment where tests ran.
+    pub environment: TestEnvironment,
+
+    /// Test results grouped by category.
+    pub results_by_category: HashMap<TestCategory, Vec<TestResult>>,
+
+    /// Overall pass/fail status.
+    pub overall_status: TestStatus,
+
+    /// When report was generated.
+    pub generated_at: u64,
+
+    /// Total duration of all tests (ms).
+    pub total_duration_ms: u64,
+
+    /// Summary statistics.
+    pub summary: CertificationSummary,
+}
+
+/// Summary statistics for certification report.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CertificationSummary {
+    pub total_tests: usize,
+    pub passed_tests: usize,
+    pub failed_tests: usize,
+    pub skipped_tests: usize,
+}
+
+impl CertificationSummary {
+    pub fn pass_rate(&self) -> f64 {
+        if self.total_tests == 0 {
+            0.0
+        } else {
+            self.passed_tests as f64 / self.total_tests as f64 * 100.0
+        }
+    }
+
+    pub fn is_passing(&self) -> bool {
+        self.failed_tests == 0
+    }
+}
+
+/// Test suite runner for certification harness.
+pub struct CertificationHarness {
+    report_id: String,
+    environment: TestEnvironment,
+    results: HashMap<TestCategory, Vec<TestResult>>,
+    #[allow(dead_code)]
+    start_time: u64,
+}
+
+impl CertificationHarness {
+    /// Creates a new certification harness.
+    pub fn new(environment: TestEnvironment) -> Self {
+        Self {
+            report_id: format!("cert_{}", uuid_short()),
+            environment,
+            results: HashMap::new(),
+            start_time: now(),
+        }
+    }
+
+    /// Records a test result.
+    pub fn record_result(&mut self, result: TestResult) {
+        self.results
+            .entry(result.category)
+            .or_insert_with(Vec::new)
+            .push(result);
+    }
+
+    /// Generates the final certification report.
+    pub fn generate_report(&self) -> CertificationReport {
+        let mut passed = 0;
+        let mut failed = 0;
+        let mut skipped = 0;
+        let mut total_duration = 0;
+
+        for results in self.results.values() {
+            for result in results {
+                match result.status {
+                    TestStatus::Passed => passed += 1,
+                    TestStatus::Failed => failed += 1,
+                    TestStatus::Skipped => skipped += 1,
+                }
+                total_duration += result.duration_ms;
+            }
+        }
+
+        let total = passed + failed + skipped;
+        let overall_status = if failed == 0 {
+            TestStatus::Passed
+        } else {
+            TestStatus::Failed
+        };
+
+        CertificationReport {
+            report_id: self.report_id.clone(),
+            environment: self.environment,
+            results_by_category: self.results.clone(),
+            overall_status,
+            generated_at: now(),
+            total_duration_ms: total_duration,
+            summary: CertificationSummary {
+                total_tests: total,
+                passed_tests: passed,
+                failed_tests: failed,
+                skipped_tests: skipped,
+            },
+        }
+    }
+
+    /// Gets the count of tests in a category.
+    pub fn test_count(&self, category: TestCategory) -> usize {
+        self.results
+            .get(&category)
+            .map(|v| v.len())
+            .unwrap_or(0)
+    }
+
+    /// Gets all failed tests.
+    pub fn failed_tests(&self) -> Vec<&TestResult> {
+        self.results
+            .values()
+            .flat_map(|v| v.iter())
+            .filter(|r| r.status == TestStatus::Failed)
+            .collect()
+    }
+}
+
+/// Test suite definition.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestSuiteDefinition {
+    pub name: String,
+    pub description: String,
+    pub categories: Vec<TestCategory>,
+    pub min_required_pass_rate: f64,
+}
+
+impl TestSuiteDefinition {
+    /// Standard certification test suite.
+    pub fn standard() -> Self {
+        Self {
+            name: "FeltDB Sherpa Certification".to_string(),
+            description: "Standard certification suite for FeltDB Sherpa enablement".to_string(),
+            categories: vec![
+                TestCategory::Authentication,
+                TestCategory::Authorization,
+                TestCategory::Pagination,
+                TestCategory::Transactions,
+                TestCategory::Operations,
+                TestCategory::Diagnostics,
+            ],
+            min_required_pass_rate: 95.0,
+        }
+    }
+
+    /// Minimal smoke test suite.
+    pub fn minimal() -> Self {
+        Self {
+            name: "FeltDB Sherpa Smoke Test".to_string(),
+            description: "Quick smoke test for basic functionality".to_string(),
+            categories: vec![
+                TestCategory::Authentication,
+                TestCategory::Authorization,
+                TestCategory::Transactions,
+            ],
+            min_required_pass_rate: 100.0,
+        }
+    }
+}
+
+/// Test execution plan.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestExecutionPlan {
+    pub suite: TestSuiteDefinition,
+    pub environment: TestEnvironment,
+    pub parallel_execution: bool,
+    pub timeout_secs: u64,
+    pub retry_failed: bool,
+    pub max_retries: u32,
+}
+
+impl TestExecutionPlan {
+    pub fn new(suite: TestSuiteDefinition, environment: TestEnvironment) -> Self {
+        Self {
+            suite,
+            environment,
+            parallel_execution: false,
+            timeout_secs: 300,
+            retry_failed: false,
+            max_retries: 0,
+        }
+    }
+
+    pub fn with_parallel(mut self) -> Self {
+        self.parallel_execution = true;
+        self
+    }
+
+    pub fn with_timeout(mut self, secs: u64) -> Self {
+        self.timeout_secs = secs;
+        self
+    }
+
+    pub fn with_retry(mut self, max_retries: u32) -> Self {
+        self.retry_failed = true;
+        self.max_retries = max_retries;
+        self
+    }
+}
+
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+fn uuid_short() -> String {
+    use std::collections::hash_map::RandomState;
+    use std::hash::{BuildHasher, Hash, Hasher};
+
+    let mut hasher = RandomState::new().build_hasher();
+    now().hash(&mut hasher);
+    format!("{:x}", hasher.finish()).chars().take(8).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn create_test_result() {
+        let result = TestResult::new(
+            "test_1".into(),
+            TestCategory::Authentication,
+            "verify_principal_creation".into(),
+        );
+
+        assert_eq!(result.status, TestStatus::Passed);
+        assert!(result.is_passing());
+        assert_eq!(result.test_id, "test_1");
+    }
+
+    #[test]
+    fn mark_test_as_failed() {
+        let result = TestResult::new(
+            "test_2".into(),
+            TestCategory::Authorization,
+            "verify_tenant_isolation".into(),
+        )
+        .failed("cross-tenant access allowed".into(), 150);
+
+        assert_eq!(result.status, TestStatus::Failed);
+        assert!(!result.is_passing());
+        assert_eq!(result.duration_ms, 150);
+    }
+
+    #[test]
+    fn certification_harness_records_results() {
+        let mut harness = CertificationHarness::new(TestEnvironment::Local);
+
+        let result1 = TestResult::new(
+            "test_1".into(),
+            TestCategory::Authentication,
+            "test_1".into(),
+        )
+        .passed(100);
+
+        let result2 = TestResult::new(
+            "test_2".into(),
+            TestCategory::Authentication,
+            "test_2".into(),
+        )
+        .failed("connection timeout".into(), 200);
+
+        harness.record_result(result1);
+        harness.record_result(result2);
+
+        assert_eq!(harness.test_count(TestCategory::Authentication), 2);
+        assert_eq!(harness.failed_tests().len(), 1);
+    }
+
+    #[test]
+    fn generate_certification_report() {
+        let mut harness = CertificationHarness::new(TestEnvironment::ManagedStaging);
+
+        for i in 0..5 {
+            let result = TestResult::new(
+                format!("test_{}", i),
+                TestCategory::Transactions,
+                format!("test_{}", i),
+            )
+            .passed(50);
+
+            harness.record_result(result);
+        }
+
+        let result_failed = TestResult::new(
+            "test_failed".into(),
+            TestCategory::Transactions,
+            "failed_test".into(),
+        )
+        .failed("assertion failed".into(), 100);
+
+        harness.record_result(result_failed);
+
+        let report = harness.generate_report();
+
+        assert_eq!(report.summary.total_tests, 6);
+        assert_eq!(report.summary.passed_tests, 5);
+        assert_eq!(report.summary.failed_tests, 1);
+        assert_eq!(report.overall_status, TestStatus::Failed);
+    }
+
+    #[test]
+    fn test_suite_definitions() {
+        let standard = TestSuiteDefinition::standard();
+        assert_eq!(standard.categories.len(), 6);
+        assert_eq!(standard.min_required_pass_rate, 95.0);
+
+        let minimal = TestSuiteDefinition::minimal();
+        assert_eq!(minimal.categories.len(), 3);
+        assert_eq!(minimal.min_required_pass_rate, 100.0);
+    }
+
+    #[test]
+    fn test_execution_plan_builder() {
+        let plan = TestExecutionPlan::new(
+            TestSuiteDefinition::standard(),
+            TestEnvironment::Local,
+        )
+        .with_parallel()
+        .with_timeout(600)
+        .with_retry(3);
+
+        assert!(plan.parallel_execution);
+        assert_eq!(plan.timeout_secs, 600);
+        assert!(plan.retry_failed);
+        assert_eq!(plan.max_retries, 3);
+    }
+
+    #[test]
+    fn certification_summary_pass_rate() {
+        let summary = CertificationSummary {
+            total_tests: 10,
+            passed_tests: 9,
+            failed_tests: 1,
+            skipped_tests: 0,
+        };
+
+        assert_eq!(summary.pass_rate(), 90.0);
+        assert!(!summary.is_passing());
+    }
+
+    #[test]
+    fn test_category_strings() {
+        assert_eq!(TestCategory::Authentication.as_str(), "authentication");
+        assert_eq!(TestCategory::Authorization.as_str(), "authorization");
+        assert_eq!(TestCategory::Pagination.as_str(), "pagination");
+        assert_eq!(TestCategory::Transactions.as_str(), "transactions");
+        assert_eq!(TestCategory::Operations.as_str(), "operations");
+        assert_eq!(TestCategory::Diagnostics.as_str(), "diagnostics");
+    }
+
+    #[test]
+    fn test_environment_strings() {
+        assert_eq!(TestEnvironment::Local.as_str(), "local");
+        assert_eq!(TestEnvironment::ManagedStaging.as_str(), "managed_staging");
+        assert_eq!(TestEnvironment::ManagedProduction.as_str(), "managed_production");
+    }
+
+    #[test]
+    fn certification_report_serialization() {
+        let mut harness = CertificationHarness::new(TestEnvironment::Local);
+
+        let result = TestResult::new(
+            "test_1".into(),
+            TestCategory::Operations,
+            "test_1".into(),
+        )
+        .passed(50);
+
+        harness.record_result(result);
+
+        let report = harness.generate_report();
+        let json = serde_json::to_string(&report).expect("serialize failed");
+        let deserialized: CertificationReport =
+            serde_json::from_str(&json).expect("deserialize failed");
+
+        assert_eq!(deserialized.report_id, report.report_id);
+        assert_eq!(deserialized.summary.total_tests, 1);
+        assert_eq!(deserialized.summary.passed_tests, 1);
+    }
+
+    #[test]
+    fn failed_tests_filter() {
+        let mut harness = CertificationHarness::new(TestEnvironment::Local);
+
+        for i in 0..3 {
+            let result = if i == 1 {
+                TestResult::new(format!("test_{}", i), TestCategory::Authorization, format!("test_{}", i))
+                    .failed("test failed".into(), 50)
+            } else {
+                TestResult::new(format!("test_{}", i), TestCategory::Authorization, format!("test_{}", i))
+                    .passed(50)
+            };
+            harness.record_result(result);
+        }
+
+        let failed = harness.failed_tests();
+        assert_eq!(failed.len(), 1);
+        assert_eq!(failed[0].test_id, "test_1");
+    }
+}