foxhunt/tests/e2e/src/clients.rs

//! Test client utilities for e2e testing
//!
//! This module contains deprecated client structs for backwards compatibility.
//! All new tests should use E2ETestFramework instead.

#![allow(deprecated)]

use crate::proto::backtesting::backtesting_service_client::BacktestingServiceClient;
use crate::proto::config::config_service_client::ConfigServiceClient;
use crate::proto::ml_training::ml_training_service_client::MlTrainingServiceClient;
use crate::proto::trading::trading_service_client::TradingServiceClient;
use anyhow::Result;
use tonic::transport::Channel;

/// Service endpoints configuration
///
/// **DEPRECATED**: This struct uses incorrect architecture (direct service connections).
/// All gRPC clients should connect through API Gateway (port 50051) with JWT authentication.
/// Use `E2ETestFramework` methods instead: `get_trading_client()`, `get_backtesting_client()`, etc.
///
/// **Incorrect Architecture**:
/// - This connects directly to backend services, bypassing API Gateway authentication
/// - Port assignments are wrong (mixing up API Gateway with service ports)
///
/// **Correct Architecture** (see `framework.rs`):
/// - All clients connect to API Gateway: `http://localhost:50051`
/// - API Gateway routes requests to backend services:
///   - Trading Service: port 50052
///   - Backtesting Service: port 50053
///   - ML Training Service: port 50054
#[deprecated(
    since = "0.1.0",
    note = "Use E2ETestFramework client methods instead. This struct bypasses API Gateway authentication."
)]
#[derive(Debug, Clone)]
pub struct ServiceEndpoints {
    pub trading: String,
    pub backtesting: String,
    pub ml_training: String,
}

impl Default for ServiceEndpoints {
    fn default() -> Self {
        Self {
            trading: "http://localhost:50051".to_string(), // WRONG: This is API Gateway, not Trading Service
            backtesting: "http://localhost:50052".to_string(), // WRONG: This is Trading Service, not Backtesting
            ml_training: "http://localhost:50053".to_string(), // WRONG: This is Backtesting Service, not ML Training
        }
    }
}

/// gRPC client suite for testing
///
/// **DEPRECATED**: Use `E2ETestFramework` instead for proper API Gateway routing and JWT authentication.
#[deprecated(
    since = "0.1.0",
    note = "Use E2ETestFramework instead. This client bypasses API Gateway."
)]
pub struct GrpcClientSuite {
    pub trading_client: Option<TradingServiceClient<Channel>>,
    pub backtesting_client: Option<BacktestingServiceClient<Channel>>,
    pub config_client: Option<ConfigServiceClient<Channel>>,
    pub ml_client: Option<MlTrainingServiceClient<Channel>>,
}

impl GrpcClientSuite {
    pub fn new() -> Result<Self> {
        Ok(Self {
            trading_client: None,
            backtesting_client: None,
            config_client: None,
            ml_client: None,
        })
    }

    pub async fn connect_all(&mut self, endpoints: ServiceEndpoints) -> Result<()> {
        // Connect to trading service
        if !endpoints.trading.is_empty() {
            let channel = Channel::from_shared(endpoints.trading)?.connect().await?;
            self.trading_client = Some(TradingServiceClient::new(channel));
        }

        // Connect to backtesting service
        if !endpoints.backtesting.is_empty() {
            let channel = Channel::from_shared(endpoints.backtesting)?
                .connect()
                .await?;
            self.backtesting_client = Some(BacktestingServiceClient::new(channel));
        }

        // Connect to ML service
        if !endpoints.ml_training.is_empty() {
            let channel = Channel::from_shared(endpoints.ml_training)?
                .connect()
                .await?;
            self.ml_client = Some(MlTrainingServiceClient::new(channel));
        }

        Ok(())
    }

    pub fn trading(&mut self) -> Option<&mut TradingServiceClient<Channel>> {
        self.trading_client.as_mut()
    }

    pub fn backtesting(&mut self) -> Option<&mut BacktestingServiceClient<Channel>> {
        self.backtesting_client.as_mut()
    }

    pub fn config(&mut self) -> Option<&mut ConfigServiceClient<Channel>> {
        self.config_client.as_mut()
    }

    pub fn ml_training(&mut self) -> Option<&mut MlTrainingServiceClient<Channel>> {
        self.ml_client.as_mut()
    }
}

/// TLI client for testing
///
/// **DEPRECATED**: Use `E2ETestFramework` instead for proper API Gateway routing and JWT authentication.
#[deprecated(
    since = "0.1.0",
    note = "Use E2ETestFramework instead. This client bypasses API Gateway."
)]
pub struct TliClient {
    pub endpoint: String,
    pub trading_client: Option<TradingServiceClient<Channel>>,
    pub backtesting_client: Option<BacktestingServiceClient<Channel>>,
    pub config_client: Option<ConfigServiceClient<Channel>>,
    pub ml_client: Option<MlTrainingServiceClient<Channel>>,
}

impl TliClient {
    pub fn new(endpoint: String) -> Self {
        Self {
            endpoint,
            trading_client: None,
            backtesting_client: None,
            config_client: None,
            ml_client: None,
        }
    }

    pub async fn connect_all(&mut self) -> Result<()> {
        let endpoints = ServiceEndpoints::default();

        // Connect to all services
        if !endpoints.trading.is_empty() {
            let channel = Channel::from_shared(endpoints.trading)?.connect().await?;
            self.trading_client = Some(TradingServiceClient::new(channel));
        }

        if !endpoints.backtesting.is_empty() {
            let channel = Channel::from_shared(endpoints.backtesting)?
                .connect()
                .await?;
            self.backtesting_client = Some(BacktestingServiceClient::new(channel));
        }

        if !endpoints.ml_training.is_empty() {
            let channel = Channel::from_shared(endpoints.ml_training)?
                .connect()
                .await?;
            self.ml_client = Some(MlTrainingServiceClient::new(channel));
        }

        Ok(())
    }

    pub fn trading(&mut self) -> Option<&mut TradingServiceClient<Channel>> {
        self.trading_client.as_mut()
    }

    pub fn backtesting(&mut self) -> Option<&mut BacktestingServiceClient<Channel>> {
        self.backtesting_client.as_mut()
    }

    pub fn config(&mut self) -> Option<&mut ConfigServiceClient<Channel>> {
        self.config_client.as_mut()
    }

    pub fn ml_training(&mut self) -> Option<&mut MlTrainingServiceClient<Channel>> {
        self.ml_client.as_mut()
    }
}