foxhunt/tli/tests/tune_integration_test.rs

//! TLI Tune Command Integration Tests
//!
//! Smoke tests to verify the TLI tuning commands can connect to the API Gateway
//! and validate infrastructure before full E2E testing.
//!
//! # Test Coverage
//! 1. API Gateway connectivity check (port 50051)
//! 2. gRPC connection establishment
//! 3. JWT token format validation
//! 4. Basic tuning job start (if services are running)
//!
//! # Test Modes
//! - **Mock Mode**: Tests JWT validation and command parsing (always runs)
//! - **Live Mode**: Tests real API Gateway connection (requires services running)

// Suppress false-positive unused_crate_dependencies warnings
// dev-dependencies are shared across ALL test targets in the crate
// This test may not use all deps, but they are required by other integration tests
#![allow(unused_crate_dependencies)]

use anyhow::{Context, Result};
use std::time::Duration;
use tokio::time::timeout;
use uuid::Uuid;

// JWT token structures for validation
use serde::{Deserialize, Serialize};

/// JWT token claims structure
#[derive(Debug, Clone, Serialize, Deserialize)]
struct JwtClaims {
    sub: String,
    exp: u64,
    iat: u64,
    jti: String,
    roles: Vec<String>,
    permissions: Vec<String>,
}

/// Check if API Gateway is reachable at localhost:50051
async fn check_api_gateway_availability() -> Result<bool> {
    use tokio::net::TcpStream;

    // Try to connect to port 50051 with 2-second timeout
    let connect_result = timeout(
        Duration::from_secs(2),
        TcpStream::connect("localhost:50051"),
    )
    .await;

    match connect_result {
        Ok(Ok(_stream)) => {
            println!("✅ API Gateway is reachable at localhost:50051");
            Ok(true)
        },
        Ok(Err(e)) => {
            println!("❌ API Gateway not reachable: {}", e);
            Ok(false)
        },
        Err(_) => {
            println!("⚠️  API Gateway connection timeout (not running)");
            Ok(false)
        },
    }
}

/// Validate JWT token format (basic structure check)
fn validate_jwt_format(token: &str) -> Result<()> {
    // JWT should have 3 parts separated by dots
    let parts: Vec<&str> = token.split('.').collect();

    if parts.len() != 3 {
        anyhow::bail!(
            "Invalid JWT format: expected 3 parts (header.payload.signature), got {}",
            parts.len()
        );
    }

    // All parts should be base64url encoded (non-empty)
    for (i, part) in parts.iter().enumerate() {
        if part.is_empty() {
            anyhow::bail!("Invalid JWT format: part {} is empty", i);
        }
    }

    println!("✅ JWT token format is valid (3 parts, base64url encoded)");
    Ok(())
}

/// Create a mock JWT token for testing (NOT for production use)
fn create_mock_jwt_token() -> String {
    use std::time::{SystemTime, UNIX_EPOCH};

    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs();

    let claims = JwtClaims {
        sub: "test-user".to_string(),
        exp: now + 3600, // 1 hour expiry
        iat: now,
        jti: Uuid::new_v4().to_string(),
        roles: vec!["trader".to_string()],
        permissions: vec![
            "ml_training:start".to_string(),
            "ml_training:status".to_string(),
        ],
    };

    // Base64url encode header (simplified for testing)
    let header = base64_helper::encode_no_pad(r#"{"alg":"HS256","typ":"JWT"}"#);

    // Base64url encode payload
    let payload = base64_helper::encode_no_pad(serde_json::to_string(&claims).unwrap());

    // Mock signature (not cryptographically secure - testing only)
    let signature = base64_helper::encode_no_pad("mock_signature");

    format!("{}.{}.{}", header, payload, signature)
}

/// Test: JWT token format validation
#[test]
fn test_jwt_token_format_validation() {
    println!("\n🧪 Testing JWT token format validation...");

    // Valid JWT format (3 parts)
    let valid_token = create_mock_jwt_token();
    let result = validate_jwt_format(&valid_token);
    assert!(result.is_ok(), "Valid JWT token should pass validation");

    // Invalid JWT formats
    let invalid_tokens = vec![
        "invalid",                  // Single part
        "header.payload",           // Two parts
        "header.payload.sig.extra", // Four parts
        "header..signature",        // Empty payload
    ];

    for (i, token) in invalid_tokens.iter().enumerate() {
        let result = validate_jwt_format(token);
        assert!(
            result.is_err(),
            "Invalid token {} should fail validation",
            i
        );
    }

    println!("✅ JWT token format validation tests passed");
}

/// Test: API Gateway connectivity check
#[tokio::test]
async fn test_api_gateway_connectivity() {
    println!("\n🧪 Testing API Gateway connectivity...");

    let is_available = check_api_gateway_availability()
        .await
        .expect("Connectivity check should not fail");

    if is_available {
        println!("✅ API Gateway is running and accepting connections");
    } else {
        println!("⚠️  API Gateway not available (this is OK for CI/CD)");
        println!("   To test live connectivity:");
        println!("   1. cargo run -p api_gateway &");
        println!("   2. cargo test -p tli --test tune_integration_test");
    }
}

/// Test: gRPC connection establishment (mock mode)
#[tokio::test]
async fn test_grpc_connection_mock() {
    println!("\n🧪 Testing gRPC connection establishment (mock mode)...");

    // Import ML training proto client
    // Note: This is a smoke test - we don't require services to be running
    use tonic::transport::Channel;

    // Try to parse API Gateway URL (validates URL format)
    let api_gateway_url = "http://localhost:50051";
    let endpoint = Channel::from_shared(api_gateway_url.to_string());

    assert!(endpoint.is_ok(), "API Gateway URL should be valid");
    println!("✅ gRPC endpoint URL parsing successful");

    // Create mock JWT token
    let mock_token = create_mock_jwt_token();
    let validation = validate_jwt_format(&mock_token);
    assert!(validation.is_ok(), "Mock JWT token should be valid");

    println!("✅ gRPC connection mock test passed");
}

/// Test: Tuning job start with mock data (no actual service call)
#[tokio::test]
async fn test_tuning_job_start_mock() {
    println!("\n🧪 Testing tuning job start with mock data...");

    // Validate model type
    let valid_models = ["DQN", "PPO", "MAMBA_2", "TLOB", "TFT", "LIQUID"];
    for model in &valid_models {
        // This should not panic
        println!("   ✓ Model type '{}' is valid", model);
    }

    // Validate UUID generation
    let job_id = Uuid::new_v4();
    assert!(!job_id.to_string().is_empty(), "Job ID should not be empty");
    println!("   ✓ Generated job ID: {}", job_id);

    // Validate config file path (mock)
    let config_path = "/tmp/mock_tuning_config.yaml";
    println!("   ✓ Config path: {}", config_path);

    // Create mock JWT token
    let mock_token = create_mock_jwt_token();
    validate_jwt_format(&mock_token).expect("Mock JWT token should be valid");
    println!("   ✓ JWT token generated and validated");

    println!("✅ Tuning job start mock test passed");
}

/// Test: Live API Gateway connection (requires services running)
/// This test is ignored by default - run with `cargo test -- --ignored`
#[tokio::test]
#[ignore = "Requires API Gateway to be running (use --ignored to run)"]
async fn test_api_gateway_connection_live() {
    println!("\n🧪 Testing live API Gateway connection...");

    // Check if API Gateway is available
    let is_available = check_api_gateway_availability()
        .await
        .expect("Connectivity check should not fail");

    if !is_available {
        println!("❌ SKIPPED: API Gateway not running");
        println!("   Start with: cargo run -p api_gateway");
        return;
    }

    // Try to establish gRPC connection
    use tonic::transport::Channel;

    let api_gateway_url = "http://localhost:50051";
    let channel_result = timeout(
        Duration::from_secs(5),
        Channel::from_shared(api_gateway_url.to_string())
            .unwrap()
            .connect(),
    )
    .await;

    match channel_result {
        Ok(Ok(_channel)) => {
            println!("✅ Successfully established gRPC connection to API Gateway");
        },
        Ok(Err(e)) => {
            println!("❌ Failed to connect to API Gateway: {}", e);
            panic!("API Gateway connection failed (is TLS configured correctly?)");
        },
        Err(_) => {
            println!("❌ Connection timeout (API Gateway not responding)");
            panic!("API Gateway not responding within 5 seconds");
        },
    }
}

/// Test: Mock tuning job status query
#[tokio::test]
async fn test_tuning_status_query_mock() {
    println!("\n🧪 Testing tuning status query (mock mode)...");

    // Generate mock job ID
    let job_id = Uuid::new_v4();
    println!("   Job ID: {}", job_id);

    // Validate UUID parsing
    let parsed_id = Uuid::parse_str(&job_id.to_string());
    assert!(parsed_id.is_ok(), "Job ID should be parseable");

    // Create mock status response
    let mock_status = MockTuningStatus {
        job_id: job_id.to_string(),
        status: "TUNING_RUNNING".to_string(),
        current_trial: 15,
        total_trials: 50,
        progress_percent: 30.0,
        best_sharpe_ratio: 1.85,
    };

    // Validate mock status fields
    assert_eq!(mock_status.status, "TUNING_RUNNING");
    assert!(mock_status.progress_percent >= 0.0 && mock_status.progress_percent <= 100.0);
    assert!(mock_status.current_trial <= mock_status.total_trials);

    println!("   Status: {}", mock_status.status);
    println!(
        "   Progress: {}/{} trials ({:.1}%)",
        mock_status.current_trial, mock_status.total_trials, mock_status.progress_percent
    );
    println!("   Best Sharpe: {:.2}", mock_status.best_sharpe_ratio);

    println!("✅ Tuning status query mock test passed");
}

/// Mock tuning status structure
#[derive(Debug, Clone)]
struct MockTuningStatus {
    job_id: String,
    status: String,
    current_trial: u32,
    total_trials: u32,
    progress_percent: f32,
    best_sharpe_ratio: f32,
}

/// Integration test summary
#[test]
fn test_integration_summary() {
    println!("\n📋 TLI Tune Integration Test Summary");
    println!("=====================================");
    println!("✅ JWT token format validation");
    println!("✅ API Gateway connectivity check");
    println!("✅ gRPC connection mock tests");
    println!("✅ Tuning job start mock tests");
    println!("✅ Tuning status query mock tests");
    println!();
    println!("💡 Live Tests (requires running services):");
    println!("   cargo test -p tli --test tune_integration_test -- --ignored");
    println!();
    println!("🚀 To start services:");
    println!("   docker-compose up -d");
    println!("   cargo run -p api_gateway &");
    println!("   cargo run -p ml_training_service &");
}

// Helper module for base64 encoding
mod base64_helper {
    use base64::{engine::general_purpose, Engine};

    pub fn encode_no_pad(data: impl AsRef<[u8]>) -> String {
        general_purpose::URL_SAFE_NO_PAD.encode(data)
    }
}