remote-mcp-kernel 0.1.0-alpha.2

//! Test cases for microkernel server
//!
//! This module contains comprehensive test cases for the microkernel server
//! to ensure independence and correct composition of handlers.

use crate::handlers::{McpServer, SseHandler, SseHandlerConfig, StreamableHttpHandler};
use oauth_provider_rs::{GitHubOAuthConfig, OAuthProvider};

use super::core::MicrokernelServer;
use super::factory::*;
use super::types::*;

fn create_test_github_oauth_provider() -> oauth_provider_rs::GitHubOAuthProvider {
    let github_config = GitHubOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };
    oauth_provider_rs::GitHubOAuthProvider::new_github(github_config)
}

fn create_test_cognito_oauth_provider() -> oauth_provider_rs::CognitoOAuthProvider {
    let cognito_config = oauth_provider_rs::CognitoOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "openid email profile".to_string(),
        provider_name: "cognito".to_string(),
    };
    oauth_provider_rs::CognitoOAuthProvider::new_cognito(
        cognito_config,
        "mydomain.auth.us-east-1.amazoncognito.com".to_string(),
        "us-east-1".to_string(),
        "us-east-1_XXXXXXXXX".to_string(),
    )
}

#[test]
fn test_microkernel_builder_empty() {
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new();
    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[test]
fn test_microkernel_builder_oauth_only_github() {
    let oauth_provider = create_test_github_oauth_provider();
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    let microkernel: GitHubMicrokernelServer =
        MicrokernelServer::new().with_oauth_provider(wrapped_oauth_provider);

    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[test]
fn test_microkernel_builder_oauth_only_cognito() {
    let oauth_provider = create_test_cognito_oauth_provider();
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    let microkernel: CognitoMicrokernelServer =
        MicrokernelServer::new().with_oauth_provider(wrapped_oauth_provider);

    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[tokio::test]
async fn test_microkernel_builder_full() {
    let oauth_provider = create_test_github_oauth_provider();
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    let mcp_server = McpServer::new();
    let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
    let sse_handler = SseHandler::new(mcp_server.clone());

    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(wrapped_oauth_provider)
        .with_streamable_handler(streamable_handler)
        .with_sse_handler(sse_handler, SseHandlerConfig::default());

    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[tokio::test]
async fn test_microkernel_factory_full() {
    let oauth_provider = create_test_github_oauth_provider();
    let microkernel = create_full_github_microkernel(oauth_provider);

    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[test]
fn test_microkernel_factory_oauth_only() {
    let oauth_provider = create_test_github_oauth_provider();
    let microkernel = create_github_oauth_only_microkernel(oauth_provider);

    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[tokio::test]
async fn test_microkernel_factory_unauthenticated() {
    let oauth_provider = create_test_github_oauth_provider();
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    let microkernel = create_unauthenticated_microkernel(wrapped_oauth_provider.clone());

    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[tokio::test]
async fn test_microkernel_independence() {
    let oauth_provider = create_test_github_oauth_provider();

    // Test that each handler can work independently
    let oauth_only = create_github_oauth_only_microkernel(oauth_provider.clone());
    assert!(oauth_only.build_router().is_ok());

    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    let mcp_server = McpServer::new();
    let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
    let streamable_only: GitHubMicrokernelServer =
        MicrokernelServer::new().with_streamable_handler(streamable_handler);
    assert!(streamable_only.build_router().is_ok());

    let sse_handler = SseHandler::new(mcp_server.clone());
    let sse_only: GitHubMicrokernelServer =
        MicrokernelServer::new().with_sse_handler(sse_handler, SseHandlerConfig::default());
    assert!(sse_only.build_router().is_ok());
}

#[tokio::test]
async fn test_microkernel_with_cognito() {
    let oauth_provider = create_test_cognito_oauth_provider();
    let microkernel = create_full_cognito_microkernel(oauth_provider);

    let router_result = microkernel.build_router();
    assert!(router_result.is_ok());
}

#[tokio::test]
async fn test_microkernel_independence_cognito() {
    let oauth_provider = create_test_cognito_oauth_provider();

    // Test that Cognito OAuth works independently
    let oauth_only = create_cognito_oauth_only_microkernel(oauth_provider);
    assert!(oauth_only.build_router().is_ok());
}