foxhunt/tli/tests/error_tests.rs

//! Unit tests for error module
//!
//! Tests all TliError variants and error handling functionality.

use tli::error::{TliError, TliResult};
use std::io;

/// Test TliError::Connection variant
#[test]
fn test_tli_error_connection() {
    let error = TliError::Connection("connection failed".to_string());

    assert!(matches!(error, TliError::Connection(_)));
    assert_eq!(error.to_string(), "Connection error: connection failed");
}

/// Test TliError::Config variant
#[test]
fn test_tli_error_config() {
    let error = TliError::Config("invalid config".to_string());

    assert!(matches!(error, TliError::Config(_)));
    assert_eq!(error.to_string(), "Configuration error: invalid config");
}

/// Test TliError::Dashboard variant
#[test]
fn test_tli_error_dashboard() {
    let error = TliError::Dashboard("render failed".to_string());

    assert!(matches!(error, TliError::Dashboard(_)));
    assert_eq!(error.to_string(), "Dashboard error: render failed");
}

/// Test TliError::Io variant from std::io::Error
#[test]
fn test_tli_error_io() {
    let io_error = io::Error::new(io::ErrorKind::NotFound, "file not found");
    let error = TliError::from(io_error);

    assert!(matches!(error, TliError::Io(_)));
    assert!(error.to_string().contains("file not found"));
}

/// Test TliError::Grpc variant from tonic::Status
#[test]
fn test_tli_error_grpc() {
    let status = tonic::Status::unavailable("service unavailable");
    let error = TliError::from(status);

    assert!(matches!(error, TliError::Grpc(_)));
    assert!(error.to_string().contains("service unavailable"));
}

/// Test TliError::InvalidRequest variant
#[test]
fn test_tli_error_invalid_request() {
    let error = TliError::InvalidRequest("negative quantity".to_string());

    assert!(matches!(error, TliError::InvalidRequest(_)));
    assert_eq!(
        error.to_string(),
        "Invalid request: negative quantity"
    );
}

/// Test TliError::NotFound variant
#[test]
fn test_tli_error_not_found() {
    let error = TliError::NotFound("order not found".to_string());

    assert!(matches!(error, TliError::NotFound(_)));
    assert_eq!(error.to_string(), "Not found: order not found");
}

/// Test TliError::BufferFull variant
#[test]
fn test_tli_error_buffer_full() {
    let error = TliError::BufferFull("event buffer full".to_string());

    assert!(matches!(error, TliError::BufferFull(_)));
    assert_eq!(error.to_string(), "Buffer full: event buffer full");
}

/// Test TliError::InvalidSymbol variant
#[test]
fn test_tli_error_invalid_symbol() {
    let error = TliError::InvalidSymbol("INVALID@123".to_string());

    assert!(matches!(error, TliError::InvalidSymbol(_)));
    assert_eq!(error.to_string(), "Invalid symbol: INVALID@123");
}

/// Test TliError::Other variant
#[test]
fn test_tli_error_other() {
    let error = TliError::Other("unexpected error".to_string());

    assert!(matches!(error, TliError::Other(_)));
    assert_eq!(error.to_string(), "Other error: unexpected error");
}

/// Test TliError debug formatting
#[test]
fn test_tli_error_debug() {
    let error = TliError::Connection("test".to_string());
    let debug_str = format!("{:?}", error);

    assert!(debug_str.contains("Connection"));
    assert!(debug_str.contains("test"));
}

/// Test TliResult with Ok value
#[test]
fn test_tli_result_ok() {
    let result: TliResult<i32> = Ok(42);

    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 42);
}

/// Test TliResult with Err value
#[test]
fn test_tli_result_err() {
    let result: TliResult<i32> = Err(TliError::Connection("failed".to_string()));

    assert!(result.is_err());
    let error = result.unwrap_err();
    assert!(matches!(error, TliError::Connection(_)));
}

/// Test error message formatting
#[test]
fn test_error_message_formatting() {
    let errors = vec![
        (
            TliError::Connection("timeout".to_string()),
            "Connection error: timeout",
        ),
        (
            TliError::Config("missing field".to_string()),
            "Configuration error: missing field",
        ),
        (
            TliError::InvalidRequest("invalid data".to_string()),
            "Invalid request: invalid data",
        ),
        (
            TliError::NotFound("resource".to_string()),
            "Not found: resource",
        ),
    ];

    for (error, expected) in errors {
        assert_eq!(error.to_string(), expected);
    }
}

/// Test error with empty message
#[test]
fn test_error_with_empty_message() {
    let error = TliError::Connection("".to_string());
    assert_eq!(error.to_string(), "Connection error: ");
}

/// Test error with very long message
#[test]
fn test_error_with_long_message() {
    let long_message = "a".repeat(10000);
    let error = TliError::Other(long_message.clone());

    assert!(error.to_string().contains(&long_message));
}

/// Test error with special characters
#[test]
fn test_error_with_special_characters() {
    let message = "Error: timeout (500ms) at server://host:8080";
    let error = TliError::Connection(message.to_string());

    assert!(error.to_string().contains(message));
}

/// Test error from different io::ErrorKind
#[test]
fn test_error_from_different_io_kinds() {
    let kinds = vec![
        io::ErrorKind::NotFound,
        io::ErrorKind::PermissionDenied,
        io::ErrorKind::ConnectionRefused,
        io::ErrorKind::TimedOut,
    ];

    for kind in kinds {
        let io_error = io::Error::new(kind, "test error");
        let tli_error = TliError::from(io_error);

        assert!(matches!(tli_error, TliError::Io(_)));
    }
}

/// Test error from different tonic::Status codes
#[test]
fn test_error_from_different_grpc_codes() {
    let statuses = vec![
        tonic::Status::unavailable("service down"),
        tonic::Status::deadline_exceeded("timeout"),
        tonic::Status::unauthenticated("no auth"),
        tonic::Status::permission_denied("forbidden"),
        tonic::Status::not_found("not found"),
    ];

    for status in statuses {
        let tli_error = TliError::from(status);
        assert!(matches!(tli_error, TliError::Grpc(_)));
    }
}

/// Test error propagation in functions
#[test]
fn test_error_propagation() {
    fn operation_that_fails() -> TliResult<()> {
        Err(TliError::Connection("failed".to_string()))
    }

    fn caller() -> TliResult<()> {
        operation_that_fails()?;
        Ok(())
    }

    let result = caller();
    assert!(result.is_err());
}

/// Test error pattern matching
#[test]
fn test_error_pattern_matching() {
    let errors = vec![
        TliError::Connection("test".to_string()),
        TliError::Config("test".to_string()),
        TliError::InvalidRequest("test".to_string()),
        TliError::NotFound("test".to_string()),
    ];

    for error in errors {
        match error {
            TliError::Connection(_) => assert!(true),
            TliError::Config(_) => assert!(true),
            TliError::InvalidRequest(_) => assert!(true),
            TliError::NotFound(_) => assert!(true),
            _ => assert!(false, "unexpected variant"),
        }
    }
}

/// Test error with newlines in message
#[test]
fn test_error_with_newlines() {
    let message = "Line 1\nLine 2\nLine 3";
    let error = TliError::Other(message.to_string());

    assert!(error.to_string().contains("Line 1"));
    assert!(error.to_string().contains("Line 2"));
}

/// Test error with unicode characters
#[test]
fn test_error_with_unicode() {
    let message = "Error: 失败 (Chinese), エラー (Japanese), ошибка (Russian)";
    let error = TliError::Connection(message.to_string());

    assert!(error.to_string().contains("失败"));
    assert!(error.to_string().contains("エラー"));
}

/// Test Result type aliases
#[test]
fn test_result_type_alias() {
    fn returns_tli_result() -> TliResult<String> {
        Ok("success".to_string())
    }

    let result = returns_tli_result();
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "success");
}

/// Test error chain with multiple error types
#[test]
fn test_error_chain() {
    fn inner_operation() -> Result<(), io::Error> {
        Err(io::Error::new(io::ErrorKind::NotFound, "inner error"))
    }

    fn outer_operation() -> TliResult<()> {
        inner_operation().map_err(|e| TliError::from(e))?;
        Ok(())
    }

    let result = outer_operation();
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), TliError::Io(_)));
}

/// Test InvalidSymbol with various invalid symbols
#[test]
fn test_invalid_symbol_variants() {
    let invalid_symbols = vec![
        "AAPL@123",
        "BTC#USD",
        "ETH-",
        "XRP!",
        "",
        "SYMBOL_TOO_LONG_FOR_TRADING_SYSTEM",
    ];

    for symbol in invalid_symbols {
        let error = TliError::InvalidSymbol(symbol.to_string());
        assert!(matches!(error, TliError::InvalidSymbol(_)));
    }
}

/// Test BufferFull with different buffer types
#[test]
fn test_buffer_full_variants() {
    let buffer_types = vec![
        "event buffer",
        "metric buffer",
        "order buffer",
        "market data buffer",
    ];

    for buffer_type in buffer_types {
        let error = TliError::BufferFull(format!("{} full", buffer_type));
        assert!(matches!(error, TliError::BufferFull(_)));
    }
}

/// Test error unwrap_or_else with fallback
#[test]
fn test_error_unwrap_or_else() {
    let result: TliResult<i32> = Err(TliError::NotFound("test".to_string()));
    let value = result.unwrap_or_else(|_| 42);

    assert_eq!(value, 42);
}

/// Test error map_err transformation
#[test]
fn test_error_map_err() {
    let result: TliResult<i32> = Err(TliError::Connection("test".to_string()));
    let transformed = result.map_err(|e| format!("Transformed: {}", e));

    assert!(transformed.is_err());
    assert!(transformed.unwrap_err().contains("Transformed"));
}