apibrasil 1.0.0

//! Rotas dos serviços de mensageria.

mod common;

use apibrasil::Method;
use common::{assert_request, build_api, ok};
use serde_json::json;

#[tokio::test]
async fn whatsapp_send_text_chama_a_rota_do_gateway() {
    let (api, transport) = build_api();

    let body = json!({ "number": "5511999999999", "text": "Olá!" });
    api.whatsapp().send_text(body.clone()).await.unwrap();

    assert_request(&transport, Method::Post, "/whatsapp/sendText", Some(body));
}

#[tokio::test]
async fn whatsapp_envia_os_headers_de_autenticacao() {
    let (api, transport) = build_api();

    api.whatsapp().qrcode(None).await.unwrap();

    assert_eq!(
        transport.last_header("Authorization").as_deref(),
        Some("Bearer jwt")
    );
    assert_eq!(transport.last_header("DeviceToken").as_deref(), Some("dev"));
    assert_eq!(
        transport.last_header("Content-Type").as_deref(),
        Some("application/json")
    );
    assert_eq!(
        transport.last_header("User-Agent").as_deref(),
        Some(apibrasil::USER_AGENT)
    );
}

#[tokio::test]
async fn whatsapp_sem_body_nao_envia_corpo() {
    let (api, transport) = build_api();

    api.whatsapp().get_all_chats(()).await.unwrap();

    assert_eq!(transport.last().body, None);
}

#[tokio::test]
async fn whatsapp_request_aceita_qualquer_action_do_catalogo() {
    let (api, transport) = build_api();

    api.whatsapp()
        .request("getBatteryLevel", None)
        .await
        .unwrap();

    assert_request(&transport, Method::Post, "/whatsapp/getBatteryLevel", None);
}

#[tokio::test]
async fn whatsapp_queue_usa_a_rota_de_fila() {
    let (api, transport) = build_api();

    api.whatsapp()
        .queue("sendText", json!({ "number": "5511999999999" }))
        .await
        .unwrap();

    assert_request(&transport, Method::Post, "/whatsapp/sendText/queue", None);
}

#[tokio::test]
async fn envelope_device_expoe_acessores_e_acesso_por_chave() {
    let (api, transport) = build_api();
    transport.respond_with(ok(json!({
        "error": false,
        "message": "sucesso",
        "response": { "id": "ABC123" },
        "api_limit": 1000,
        "api_limit_for": "day",
        "api_limit_used": 3,
    })));

    let response = api
        .whatsapp()
        .send_text(json!({ "number": "5511999999999", "text": "oi" }))
        .await
        .unwrap();

    assert!(!response.is_error());
    assert_eq!(response.message(), Some("sucesso"));
    assert_eq!(response.api_limit(), Some(&json!(1000)));
    assert_eq!(response.api_limit_for(), Some(&json!("day")));
    assert_eq!(response.api_limit_used(), Some(&json!(3)));
    assert_eq!(response["response"]["id"], json!("ABC123"));

    #[derive(serde::Deserialize)]
    struct Enviado {
        id: String,
    }
    let enviado: Enviado = response.decode().unwrap();
    assert_eq!(enviado.id, "ABC123");
}

#[tokio::test]
async fn whatsmeow_usa_as_rotas_aninhadas() {
    let (api, transport) = build_api();

    api.whatsmeow()
        .send_text(json!({ "text": "oi" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/whatsmeow/send/text", None);

    api.whatsmeow().instance_qr(None).await.unwrap();
    assert_request(&transport, Method::Post, "/whatsmeow/instance/qr", None);
}

#[tokio::test]
async fn sms_send_e_send_with_credits_usam_rotas_distintas() {
    let (api, transport) = build_api();

    api.sms()
        .send(json!({ "number": "5511999999999", "message": "oi" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/sms/send", None);

    transport.respond_with(ok(json!({ "error": false, "balance": 10 })));
    let credito = api
        .sms()
        .send_with_credits(json!({ "number": "5511999999999", "message": "oi" }))
        .await
        .unwrap();

    assert_request(&transport, Method::Post, "/sms/send/credits", None);
    assert_eq!(credito.balance(), Some(&json!(10)));
}

#[tokio::test]
async fn evolution_monta_controller_e_action() {
    let (api, transport) = build_api();

    api.evolution()
        .request("message", "sendText", json!({ "number": "5511999999999" }))
        .await
        .unwrap();
    assert_request(
        &transport,
        Method::Post,
        "/evolution/message/sendText",
        None,
    );

    api.evolution().call("instance/create", None).await.unwrap();
    assert_request(&transport, Method::Post, "/evolution/instance/create", None);

    api.evolution()
        .queue("message", "sendText", None)
        .await
        .unwrap();
    assert_request(
        &transport,
        Method::Post,
        "/evolution/message/sendText/queue",
        None,
    );
}