ltfi-wsap 2.0.2

use ltfi_wsap::{Client, WSAPError, models::*};
use mockito::{Server, Mock};
use tokio_test;

#[tokio::test]
async fn test_client_initialization() {
    let client = Client::new("test-api-key", None);
    assert_eq!(client.api_key, "test-api-key");
    assert_eq!(client.base_url, "https://api.ltfi.ai");
}

#[tokio::test]
async fn test_client_with_custom_base_url() {
    let client = Client::new("test-api-key", Some("https://custom.api.com".to_string()));
    assert_eq!(client.base_url, "https://custom.api.com");
}

#[tokio::test]
async fn test_list_entities() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let mock_response = serde_json::json!({
        "count": 1,
        "results": [{
            "id": 1,
            "entity_id": "test-uuid",
            "entity_type": "company",
            "display_name": "Test Company",
            "slug": "test-company-123",
            "parent_entity": null,
            "created_by": 1,
            "is_active": true,
            "is_published": true,
            "is_verified": false,
            "template_id": null,
            "inherits_from_parent": false,
            "wsap_data": {},
            "created_at": "2023-01-01T00:00:00Z",
            "updated_at": "2023-01-01T00:00:00Z"
        }]
    });

    let _mock = server
        .mock("GET", "/api/entities/")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(mock_response.to_string())
        .create_async()
        .await;

    let client = Client::new("test-api-key", Some(base_url));
    let result = client.list_entities(None).await.unwrap();
    
    assert_eq!(result.count, 1);
    assert_eq!(result.results.len(), 1);
    assert_eq!(result.results[0].display_name, "Test Company");
}

#[tokio::test]
async fn test_get_entity() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let mock_entity = serde_json::json!({
        "id": 1,
        "entity_id": "test-uuid",
        "entity_type": "company",
        "display_name": "Test Company",
        "slug": "test-company-123",
        "parent_entity": null,
        "created_by": 1,
        "is_active": true,
        "is_published": true,
        "is_verified": false,
        "template_id": null,
        "inherits_from_parent": false,
        "wsap_data": {},
        "created_at": "2023-01-01T00:00:00Z",
        "updated_at": "2023-01-01T00:00:00Z"
    });

    let _mock = server
        .mock("GET", "/api/entities/test-company-123/")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(mock_entity.to_string())
        .create_async()
        .await;

    let client = Client::new("test-api-key", Some(base_url));
    let entity = client.get_entity("test-company-123").await.unwrap();
    
    assert_eq!(entity.display_name, "Test Company");
    assert_eq!(entity.slug, "test-company-123");
    assert_eq!(entity.entity_type, EntityType::Company);
}

#[tokio::test]
async fn test_get_entity_not_found() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let _mock = server
        .mock("GET", "/api/entities/nonexistent/")
        .with_status(404)
        .create_async()
        .await;

    let client = Client::new("test-api-key", Some(base_url));
    let result = client.get_entity("nonexistent").await;
    
    assert!(matches!(result, Err(WSAPError::NotFound(_))));
}

#[tokio::test]
async fn test_create_entity() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let mock_entity = serde_json::json!({
        "id": 1,
        "entity_id": "test-uuid",
        "entity_type": "company",
        "display_name": "New Company",
        "slug": "new-company-123",
        "parent_entity": null,
        "created_by": 1,
        "is_active": true,
        "is_published": false,
        "is_verified": false,
        "template_id": null,
        "inherits_from_parent": false,
        "wsap_data": {},
        "created_at": "2023-01-01T00:00:00Z",
        "updated_at": "2023-01-01T00:00:00Z"
    });

    let _mock = server
        .mock("POST", "/api/entities/")
        .with_status(201)
        .with_header("content-type", "application/json")
        .with_body(mock_entity.to_string())
        .create_async()
        .await;

    let client = Client::new("test-api-key", Some(base_url));
    let create_request = CreateEntityRequest {
        entity_type: EntityType::Company,
        display_name: "New Company".to_string(),
        parent_entity: None,
        template_id: None,
        inherits_from_parent: Some(false),
    };
    
    let entity = client.create_entity(create_request).await.unwrap();
    assert_eq!(entity.display_name, "New Company");
    assert_eq!(entity.entity_type, EntityType::Company);
}

#[tokio::test]
async fn test_initiate_verification() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let mock_verification = serde_json::json!({
        "id": "verification-uuid",
        "entity": 1,
        "domain": "example.com",
        "verification_token": "test-token",
        "txt_record_name": "_wsap-verify.example.com",
        "txt_record_value": "wsap-verify=test-token",
        "verification_method": "dns",
        "status": "pending",
        "verified_at": null,
        "attempts": 0,
        "max_attempts": 3
    });

    let _mock = server
        .mock("POST", "/api/verification/initiate/")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(mock_verification.to_string())
        .create_async()
        .await;

    let client = Client::new("test-api-key", Some(base_url));
    let result = client.initiate_verification("example.com").await.unwrap();
    
    assert_eq!(result.domain, "example.com");
    assert_eq!(result.status, "pending");
    assert_eq!(result.verification_token, "test-token");
}

#[tokio::test]
async fn test_verify_domain() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let mock_response = serde_json::json!({
        "verified": true
    });

    let _mock = server
        .mock("POST", "/api/verification/verify/")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(mock_response.to_string())
        .create_async()
        .await;

    let client = Client::new("test-api-key", Some(base_url));
    let result = client.verify_domain("example.com").await.unwrap();
    
    assert!(result);
}

#[tokio::test]
async fn test_generate_wsap() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let mock_wsap = serde_json::json!({
        "version": "2.0",
        "entity_id": "test-company-123",
        "domain": "example.com",
        "disclosure_level": "STANDARD",
        "generated_at": "2023-01-01T00:00:00Z",
        "expires_at": null,
        "data": {}
    });

    let _mock = server
        .mock("POST", "/api/wsap/generate/")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(mock_wsap.to_string())
        .create_async()
        .await;

    let client = Client::new("test-api-key", Some(base_url));
    let result = client.generate_wsap("test-company-123", DisclosureLevel::Standard).await.unwrap();
    
    assert_eq!(result.entity_id, "test-company-123");
    assert_eq!(result.version, "2.0");
    assert_eq!(result.disclosure_level, DisclosureLevel::Standard);
}

#[tokio::test]
async fn test_authentication_error() {
    let mut server = Server::new_async().await;
    let base_url = server.url();
    
    let _mock = server
        .mock("GET", "/api/entities/")
        .with_status(401)
        .create_async()
        .await;

    let client = Client::new("invalid-api-key", Some(base_url));
    let result = client.list_entities(None).await;
    
    assert!(matches!(result, Err(WSAPError::Authentication(_))));
}