apibrasil 1.0.0

//! Rotas dos serviços de dados e das consultas por crédito.

mod common;

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

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

    api.dados()
        .cnpj(json!({ "cnpj": "00000000000000" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/dados/cnpj", None);

    api.dados()
        .cpf(json!({ "cpf": "00000000000" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/dados/cpf", None);

    api.dados()
        .lista_socios(json!({ "cnpj": "0" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/dados/lista-socios", None);

    api.dados().by_query(json!({ "uf": "SP" })).await.unwrap();
    assert_request(&transport, Method::Post, "/dados/byquery", None);
}

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

    api.cep().cep(json!({ "cep": "01001000" })).await.unwrap();
    assert_request(&transport, Method::Post, "/cep/cep", None);

    api.cep()
        .cidades_por_ddd(json!({ "ddd": 11 }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/cep/cidadesPorDDD", None);

    api.cep()
        .calcular_distancia(json!({ "de": "1", "para": "2" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/cep/distancia/calcular", None);
}

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

    api.vehicles()
        .dados(json!({ "placa": "ABC1234" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/vehicles/dados", None);

    api.vehicles()
        .base_fipe(json!({ "placa": "ABC1234" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/vehicles/base/000/fipe", None);

    api.vehicles().consulta_fipe("ABC1234").await.unwrap();
    assert_request(
        &transport,
        Method::Post,
        "/vehicles/consultafipe/ABC1234",
        None,
    );
}

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

    api.fipe()
        .consultar_marcas(json!({ "codigoTabelaReferencia": 300 }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/fipe/ConsultarMarcas", None);

    api.fipe()
        .consultar_valor_com_todos_parametros(None)
        .await
        .unwrap();
    assert_request(
        &transport,
        Method::Post,
        "/fipe/ConsultarValorComTodosParametros",
        None,
    );
}

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

    api.correios()
        .rastreio(json!({ "codigo": "AA123" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/correios/rastreio", None);

    api.geolocation()
        .geocode(json!({ "address": "x" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/geolocation/geocode", None);

    api.geomatrix().distance(None).await.unwrap();
    assert_request(&transport, Method::Post, "/geomatrix/distance", None);

    api.recognize()
        .base64(json!({ "image": "x" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/recognize/base64", None);

    api.holidays()
        .feriados(json!({ "ano": 2026 }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/holidays/feriados", None);

    api.translate()
        .identify(json!({ "text": "hello" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/translate/identify", None);

    api.weather()
        .city(json!({ "city": "São Paulo" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/weather/city", None);

    api.ddd()
        .request("ddd", json!({ "ddd": 11 }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/ddd/ddd", None);

    api.database_ip()
        .ip(json!({ "ip": "8.8.8.8" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/database/ip", None);
}

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

    api.loterias()
        .resultado("megasena", 2700, None)
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/loterias/megasena/2700", None);

    api.loterias().latest("quina", None).await.unwrap();
    assert_request(&transport, Method::Post, "/loterias/quina/latest", None);
}

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

    api.ura()
        .dialler(json!({ "number": "5511999999999" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/ura/call/dialler", None);

    api.chip_virtual().operators(None).await.unwrap();
    assert_request(&transport, Method::Post, "/chip/virtual/operators", None);

    api.bulk()
        .direct("cnpj", json!({ "items": [] }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/bulk/direct/cnpj", None);

    api.bulk()
        .queue("cnpj", json!({ "items": [] }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/bulk/queue/cnpj", None);
}

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

    api.consulta()
        .cpf(json!({ "cpf": "00000000000" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/consulta/cpf/credits", None);

    api.consulta()
        .ddd_anatel(json!({ "ddd": 11 }))
        .await
        .unwrap();
    assert_request(
        &transport,
        Method::Post,
        "/consulta/ddd-anatel/credits",
        None,
    );

    api.consulta().weather(None).await.unwrap();
    assert_request(
        &transport,
        Method::Post,
        "/consulta/weather-api/credits",
        None,
    );

    api.consulta()
        .generic("cnh", json!({ "cpf": "0" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/consulta/cnh/credits", None);

    api.consulta().credits("cpf").await.unwrap();
    assert_request(&transport, Method::Get, "/consulta/cpf/credits", None);
}

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

    api.consulta().quod(json!({ "cnpj": "0" })).await.unwrap();
    assert_request(&transport, Method::Post, "/quod/cnpj/credits", None);

    api.consulta()
        .veiculos_base("dados", json!({ "placa": "ABC1234" }))
        .await
        .unwrap();
    assert_request(&transport, Method::Post, "/vehicles/base/000/dados", None);

    api.consulta().proxy_seller(None).await.unwrap();
    assert_request(&transport, Method::Post, "/proxy/seller/credits", None);
}

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

    api.consulta()
        .cnpj(
            Consulta::new("lista-socios")
                .homolog(true)
                .lite(true)
                .agrupados(["a", "b"])
                .extra(["c"])
                .field("cnpj", "00000000000000"),
        )
        .await
        .unwrap();

    assert_request(
        &transport,
        Method::Post,
        "/consulta/cnpj/credits",
        Some(json!({
            "tipo": "lista-socios",
            "homolog": true,
            "lite": true,
            "agrupados": ["a", "b"],
            "extra": ["c"],
            "cnpj": "00000000000000",
        })),
    );
}

#[tokio::test]
async fn envelope_de_credito_expoe_saldo_e_dados() {
    let (api, transport) = build_api();
    transport.respond_with(ok(json!({
        "error": false,
        "message": "ok",
        "balance": 42.5,
        "tax": 0.1,
        "valor_consulta": 1.5,
        "homolog": true,
        "data": { "nome": "EMPRESA LTDA" },
    })));

    let consulta = api.consulta().cnpj(json!({ "cnpj": "0" })).await.unwrap();

    assert!(!consulta.is_error());
    assert_eq!(consulta.message(), Some("ok"));
    assert_eq!(consulta.balance(), Some(&json!(42.5)));
    assert_eq!(consulta.tax(), Some(&json!(0.1)));
    assert_eq!(consulta.valor_consulta(), Some(&json!(1.5)));
    assert!(consulta.homolog());
    assert_eq!(consulta.data().unwrap()["nome"], json!("EMPRESA LTDA"));
}