foxhunt/trading_engine/tests/audit_compliance_part2_rewrite.rs

//! Audit Compliance Tests - Part 2 Rewrite (Lines 500-1000)
//! Wave 112 Agent 10: Proper rewrite using actual Wave 107 API
//!
//! Tests rewritten to use ONLY available AuditTrailEngine methods:
//! - new(config)
//! - log_event(event)
//! - query(query) -> AuditTrailQueryResult

use chrono::{DateTime, Duration, Utc};
use rust_decimal::Decimal;
use std::collections::HashMap;
use std::sync::Arc;
use trading_engine::compliance::audit_trails::{
    AuditEventDetails, AuditEventType, AuditTrailConfig, AuditTrailEngine, AuditTrailQuery,
    ComplianceRequirements, PartitioningStrategy, RiskLevel, SortOrder, StorageBackendConfig,
    StorageType, TransactionAuditEvent,
};
use trading_engine::persistence::postgres::{PostgresConfig, PostgresPool};

async fn create_test_postgres_pool() -> Option<Arc<PostgresPool>> {
    let postgres_config = PostgresConfig {
        url: std::env::var("DATABASE_URL")
            .unwrap_or_else(|_| "postgresql://postgres:postgres@localhost:5433/foxhunt".to_owned()),
        max_connections: 5,
        min_connections: 1,
        connect_timeout_ms: 5000,
        query_timeout_micros: 100_000,
        acquire_timeout_ms: 1000,
        max_lifetime_seconds: 300,
        idle_timeout_seconds: 60,
        enable_prewarming: false,
        enable_prepared_statements: true,
        enable_slow_query_logging: false,
        slow_query_threshold_micros: 10_000,
    };

    match PostgresPool::new(postgres_config).await {
        Ok(pool) => Some(Arc::new(pool)),
        Err(e) => {
            eprintln!("⚠️  Database not available: {} - Skipping DB tests", e);
            None
        },
    }
}

fn create_test_audit_config(pg_pool: Option<Arc<PostgresPool>>) -> AuditTrailConfig {
    AuditTrailConfig {
        real_time_persistence: true,
        buffer_size: 1000,
        batch_size: 100,
        flush_interval_ms: 100,
        retention_days: 2555, // 7 years for SOX
        compression_enabled: true,
        encryption_enabled: true,
        storage_backend: StorageBackendConfig {
            primary_storage: StorageType::PostgreSQL,
            backup_storage: None,
            connection_string: "postgresql://postgres:password@localhost:5432/foxhunt_test"
                .to_owned(),
            table_name: "audit_trail".to_owned(),
            partitioning: PartitioningStrategy::Daily,
        },
        compliance_requirements: ComplianceRequirements {
            sox_enabled: true,
            mifid_ii_enabled: true,
            immutable_required: true,
            digital_signatures_enabled: true,
            tamper_detection: true,
        },
    }
}

fn create_test_audit_event(event_id: &str, actor: &str) -> TransactionAuditEvent {
    TransactionAuditEvent {
        event_id: event_id.to_owned(),
        timestamp: Utc::now(),
        timestamp_nanos: Utc::now().timestamp_nanos_opt().unwrap_or(0) as u64,
        event_type: AuditEventType::OrderCreated,
        transaction_id: format!("tx_{}", event_id),
        order_id: format!("order_{}", event_id),
        actor: actor.to_owned(),
        session_id: Some(format!("session_{}", actor)),
        client_ip: Some("127.0.0.1".to_owned()),
        details: AuditEventDetails {
            symbol: Some("AAPL".to_owned()),
            quantity: Some(Decimal::from(100)),
            price: Some(Decimal::from(150)),
            side: Some("BUY".to_owned()),
            order_type: Some("LIMIT".to_owned()),
            venue: Some("XNYS".to_owned()),
            account_id: Some("ACC001".to_owned()),
            strategy_id: Some("STRAT001".to_owned()),
            metadata: HashMap::new(),
            performance_metrics: None,
        },
        before_state: None,
        after_state: None,
        compliance_tags: vec!["SOX".to_owned(), "MIFID2".to_owned()],
        risk_level: RiskLevel::Low,
        digital_signature: None,
        checksum: String::new(),
    }
}

/// Test 7: Internal control effectiveness - simplified using available API
/// Validates that critical operations are logged in audit trail
#[tokio::test]
async fn test_sox_internal_control_effectiveness() {
    let pg_pool = create_test_postgres_pool().await;
    if pg_pool.is_none() {
        println!("⚠️  Skipping test_sox_internal_control_effectiveness - database unavailable");
        return;
    }

    let config = create_test_audit_config(pg_pool.clone());
    let audit_engine = AuditTrailEngine::new(config);

    if let Some(pool) = pg_pool {
        audit_engine.set_postgres_pool(pool).await;
    }

    // Log configuration change initiation
    let mut config_change_event = create_test_audit_event("CONFIG_CHANGE_001", "devA");
    config_change_event.event_type = AuditEventType::SystemEvent;
    config_change_event.details.metadata.insert(
        "action".to_owned(),
        serde_json::Value::String("config_change_initiated".to_owned()),
    );
    config_change_event.details.metadata.insert(
        "param".to_owned(),
        serde_json::Value::String("max_daily_loss".to_owned()),
    );

    audit_engine
        .log_event(config_change_event.clone())
        .expect("Failed to log config change");

    // Log approval attempt (should be separate actor for four-eyes principle)
    let mut approval_event = create_test_audit_event("CONFIG_APPROVAL_001", "devB");
    approval_event.event_type = AuditEventType::SystemEvent;
    approval_event.details.metadata.insert(
        "action".to_owned(),
        serde_json::Value::String("config_change_approved".to_owned()),
    );

    audit_engine
        .log_event(approval_event)
        .expect("Failed to log approval");

    // Query for configuration change events
    let query = AuditTrailQuery {
        start_time: Utc::now() - Duration::hours(1),
        end_time: Utc::now(),
        event_types: Some(vec![AuditEventType::SystemEvent]),
        actor: Some("devA".to_owned()),
        ..Default::default()
    };

    let results = audit_engine.query(query).await.expect("Query failed");

    assert!(
        results.events.len() >= 1,
        "Should record configuration change initiation"
    );

    println!("✅ SOX Test 7: Internal control effectiveness verified (simplified)");
}

/// Test 8: Segregation of duties - using audit logging to verify
#[tokio::test]
async fn test_sox_segregation_of_duties() {
    let pg_pool = create_test_postgres_pool().await;
    if pg_pool.is_none() {
        println!("⚠️  Skipping test_sox_segregation_of_duties - database unavailable");
        return;
    }

    let config = create_test_audit_config(pg_pool.clone());
    let audit_engine = AuditTrailEngine::new(config);

    if let Some(pool) = pg_pool {
        audit_engine.set_postgres_pool(pool).await;
    }

    // Log deployment attempt by developer (should fail in real system)
    let mut deploy_event = create_test_audit_event("DEPLOY_001", "devC");
    deploy_event.event_type = AuditEventType::SystemEvent;
    deploy_event.risk_level = RiskLevel::High;
    deploy_event.details.metadata.insert(
        "action".to_owned(),
        serde_json::Value::String("deployment_attempted".to_owned()),
    );
    deploy_event.details.metadata.insert(
        "result".to_owned(),
        serde_json::Value::String("denied_insufficient_privileges".to_owned()),
    );

    audit_engine
        .log_event(deploy_event)
        .expect("Failed to log deployment attempt");

    // Log successful deployment by release manager
    let mut authorized_deploy = create_test_audit_event("DEPLOY_002", "releaseManagerY");
    authorized_deploy.event_type = AuditEventType::SystemEvent;
    authorized_deploy.risk_level = RiskLevel::Medium;
    authorized_deploy.details.metadata.insert(
        "action".to_owned(),
        serde_json::Value::String("deployment_completed".to_owned()),
    );

    audit_engine
        .log_event(authorized_deploy)
        .expect("Failed to log authorized deployment");

    // Query for deployment events
    let query = AuditTrailQuery {
        start_time: Utc::now() - Duration::hours(1),
        end_time: Utc::now(),
        event_types: Some(vec![AuditEventType::SystemEvent]),
        ..Default::default()
    };

    let results = audit_engine.query(query).await.expect("Query failed");

    assert!(
        results.events.len() >= 2,
        "Should record both deployment attempts"
    );

    // Verify denied deployment is logged
    let denied = results.events.iter().find(|e| e.actor == "devC");
    assert!(denied.is_some(), "Should log denied deployment");

    println!("✅ SOX Test 8: Segregation of duties verified (simplified)");
}

/// Test 9: Change management audit - track configuration changes
#[tokio::test]
async fn test_sox_change_management_audit() {
    let pg_pool = create_test_postgres_pool().await;
    if pg_pool.is_none() {
        println!("⚠️  Skipping test_sox_change_management_audit - database unavailable");
        return;
    }

    let config = create_test_audit_config(pg_pool.clone());
    let audit_engine = AuditTrailEngine::new(config);

    if let Some(pool) = pg_pool {
        audit_engine.set_postgres_pool(pool).await;
    }

    // Log config change 1
    let mut change1 = create_test_audit_event("CONFIG_CHG_001", "adminUser");
    change1.event_type = AuditEventType::SystemEvent;
    change1.details.metadata.insert(
        "config_item".to_owned(),
        serde_json::Value::String("algo_threshold".to_owned()),
    );
    change1.details.metadata.insert(
        "old_value".to_owned(),
        serde_json::Value::String("0.05".to_owned()),
    );
    change1.details.metadata.insert(
        "new_value".to_owned(),
        serde_json::Value::String("0.055".to_owned()),
    );

    audit_engine
        .log_event(change1)
        .expect("Failed to log change 1");

    // Log config change 2
    let mut change2 = create_test_audit_event("CONFIG_CHG_002", "riskManager");
    change2.event_type = AuditEventType::SystemEvent;
    change2.details.metadata.insert(
        "config_item".to_owned(),
        serde_json::Value::String("max_position_size".to_owned()),
    );
    change2.details.metadata.insert(
        "old_value".to_owned(),
        serde_json::Value::String("500000".to_owned()),
    );
    change2.details.metadata.insert(
        "new_value".to_owned(),
        serde_json::Value::String("1000000".to_owned()),
    );

    audit_engine
        .log_event(change2)
        .expect("Failed to log change 2");

    // Query for config changes
    let query = AuditTrailQuery {
        start_time: Utc::now() - Duration::hours(1),
        end_time: Utc::now(),
        event_types: Some(vec![AuditEventType::SystemEvent]),
        ..Default::default()
    };

    let results = audit_engine.query(query).await.expect("Query failed");

    assert!(
        results.events.len() >= 2,
        "Should record both config changes"
    );

    // Verify first change details
    let algo_change = results.events.iter().find(|e| e.actor == "adminUser");
    assert!(algo_change.is_some(), "Should find algo_threshold change");

    if let Some(change) = algo_change {
        assert_eq!(
            change
                .details
                .metadata
                .get("config_item")
                .and_then(|v| v.as_str()),
            Some("algo_threshold"),
            "Should record config item"
        );
    }

    println!("✅ SOX Test 9: Change management audit verified (simplified)");
}

/// Test 10: Exception handling audit - verify error logging
#[tokio::test]
async fn test_sox_exception_handling_audit() {
    let pg_pool = create_test_postgres_pool().await;
    if pg_pool.is_none() {
        println!("⚠️  Skipping test_sox_exception_handling_audit - database unavailable");
        return;
    }

    let config = create_test_audit_config(pg_pool.clone());
    let audit_engine = AuditTrailEngine::new(config);

    if let Some(pool) = pg_pool {
        audit_engine.set_postgres_pool(pool).await;
    }

    // Log error 1: Invalid market data
    let mut error1 = create_test_audit_event("ERR_001", "system");
    error1.event_type = AuditEventType::ErrorEvent;
    error1.risk_level = RiskLevel::High;
    error1.details.metadata.insert(
        "error_type".to_owned(),
        serde_json::Value::String("invalid_market_data".to_owned()),
    );
    error1.details.metadata.insert(
        "component".to_owned(),
        serde_json::Value::String("trading_engine".to_owned()),
    );
    error1.details.metadata.insert(
        "stack_trace".to_owned(),
        serde_json::Value::String("Error at line 123".to_owned()),
    );

    audit_engine
        .log_event(error1)
        .expect("Failed to log error 1");

    // Log error 2: Network timeout
    let mut error2 = create_test_audit_event("ERR_002", "system");
    error2.event_type = AuditEventType::ErrorEvent;
    error2.risk_level = RiskLevel::Medium;
    error2.details.metadata.insert(
        "error_type".to_owned(),
        serde_json::Value::String("network_timeout".to_owned()),
    );

    audit_engine
        .log_event(error2)
        .expect("Failed to log error 2");

    // Log error 3: Database failure
    let mut error3 = create_test_audit_event("ERR_003", "system");
    error3.event_type = AuditEventType::ErrorEvent;
    error3.risk_level = RiskLevel::Critical;
    error3.details.metadata.insert(
        "error_type".to_owned(),
        serde_json::Value::String("database_connection_failure".to_owned()),
    );

    audit_engine
        .log_event(error3)
        .expect("Failed to log error 3");

    // Query for errors
    let query = AuditTrailQuery {
        start_time: Utc::now() - Duration::hours(1),
        end_time: Utc::now(),
        event_types: Some(vec![AuditEventType::ErrorEvent]),
        ..Default::default()
    };

    let results = audit_engine.query(query).await.expect("Query failed");

    assert_eq!(results.events.len(), 3, "Should log all 3 errors");

    // Verify market data error details
    let market_data_error = results.events.iter().find(|e| {
        e.details.metadata.get("component").and_then(|v| v.as_str()) == Some("trading_engine")
    });

    assert!(market_data_error.is_some(), "Should find market data error");

    if let Some(error) = market_data_error {
        assert_eq!(
            error.risk_level,
            RiskLevel::High,
            "Should mark as high severity"
        );
        assert!(
            error.details.metadata.contains_key("error_type"),
            "Should include error type"
        );
        assert!(
            error.details.metadata.contains_key("stack_trace"),
            "Should include stack trace"
        );
    }

    println!("✅ SOX Test 10: Exception handling audit verified (simplified)");
}