poimen-memory/tests/it_gateway_queue_adapter.rs.disabled.rs.disabled

//! Integration tests for M8.2 Gateway Queue Adapter
//!
//! Tests the unified queue adapter that routes SQS messages through api.riotpiao.com gateway.

use mem_cli::queue_adapter::{QueueAdapter, QueueMessage};
use mem_cli::gateway_queue_adapter::{GatewayQueueAdapter, StaticTokenProvider};
use std::sync::Arc;
use uuid::Uuid;

#[tokio::test]
async fn test_static_queue_adapter_creation() {
    let adapter = GatewayQueueAdapter::with_static_token(
        "https://api.riotpiao.com".to_string(),
        "test-token-xyz".to_string(),
    );

    // Verify adapter is created
    assert!(adapter.health_check().await.is_err());  // Will fail (no real gateway), but tests flow
}

#[tokio::test]
async fn test_queue_message_serialization() {
    let msg = QueueMessage {
        message_id: "msg-123".to_string(),
        chunk_id: Uuid::new_v4(),
        body: "test body".to_string(),
        receive_count: 1,
        receipt_handle: "handle-xyz".to_string(),
        project: "myproject".to_string(),
        attributes: std::collections::HashMap::new(),
    };

    assert_eq!(msg.message_id, "msg-123");
    assert_eq!(msg.project, "myproject");
    assert_eq!(msg.receive_count, 1);
}

#[test]
fn test_gateway_queue_naming() {
    let adapter = GatewayQueueAdapter::with_static_token(
        "https://api.riotpiao.com".to_string(),
        "test-token".to_string(),
    );

    assert_eq!(adapter.queue_name("myproject"), "poimen-chunks-myproject");
    assert_eq!(adapter.queue_name("prod"), "poimen-chunks-prod");
    assert_eq!(adapter.queue_name("test-env"), "poimen-chunks-test-env");
}

#[test]
fn test_queue_adapter_base64_encoding() {
    let original = "hello world";
    let encoded = base64::encode(original.as_bytes());
    let decoded_bytes = base64::decode(encoded.as_bytes()).unwrap();
    let decoded = String::from_utf8(decoded_bytes).unwrap();

    assert_eq!(decoded, original);
}

#[test]
fn test_json_chunk_message() {
    let chunk_data = serde_json::json!({
        "chunk_id": Uuid::new_v4(),
        "content": "test content",
        "source": "obsidian",
        "level": "L0",
        "breadcrumb": ["root", "section1"],
    });

    assert_eq!(chunk_data["level"], "L0");
    assert_eq!(chunk_data["source"], "obsidian");
}

#[tokio::test]
async fn test_authentik_token_provider_construction() {
    use mem_cli::gateway_queue_adapter::AuthentikTokenProvider;

    let provider = AuthentikTokenProvider::new(
        "https://authentik.riotpiao.com/application/o/poimen-memory/".to_string(),
        "client-id".to_string(),
        "client-secret".to_string(),
    );

    // Just test that it constructs (won't actually authenticate without real Authentik)
    let _ = provider;
}

#[test]
fn test_queue_stats_structure() {
    use mem_cli::queue_adapter::QueueStats;

    let stats = QueueStats {
        available_messages: 10,
        in_flight_messages: 3,
        dead_letter_messages: 1,
        total_processed: 100,
        average_delay_secs: 45,
    };

    assert_eq!(stats.available_messages, 10);
    assert_eq!(stats.in_flight_messages, 3);
    assert_eq!(stats.total_processed, 100);
    assert!(stats.average_delay_secs > 0);
}

#[test]
fn test_message_attributes_serialization() {
    let mut attrs = std::collections::HashMap::new();
    attrs.insert("source".to_string(), "obsidian".to_string());
    attrs.insert("level".to_string(), "L0".to_string());

    let json = serde_json::to_string(&attrs).unwrap();
    assert!(json.contains("source"));
    assert!(json.contains("obsidian"));
}

#[test]
fn test_breadcrumb_path_encoding() {
    let breadcrumb = vec!["root".to_string(), "folder1".to_string(), "section".to_string()];
    let json = serde_json::to_string(&breadcrumb).unwrap();

    assert_eq!(json, r#"["root","folder1","section"]"#);
}