taler-rust

test.rs (7993B)

---

 use std::sync::{Arc, LazyLock};
 
 use axum::{
     Router,
     http::{StatusCode, header},
 };
 use serde_json::json;
 use sqlx::{PgPool, Row as _, postgres::PgRow};
 use taler_common::{
     api_common::{HashCode, ShortHashCode},
     api_revenue::RevenueConfig,
     api_transfer::PreparedTransferConfig,
     api_wire::{OutgoingHistory, TransferRequest, TransferResponse, TransferState, WireConfig},
     db::IncomingType,
     error_code::ErrorCode,
     types::{
         amount::{Amount, Currency, amount},
         base32::Base32,
         payto::{PaytoURI, payto},
         url,
     },
 };
 use taler_test_utils::{
     db::db_test_setup_manual,
     routine::{
         Status, admin_add_incoming_routine, in_history_routine, registration_routine,
         revenue_routine, routine_pagination, transfer_routine,
     },
     server::TestServer,
 };
 use tokio::sync::watch::Sender;
 
 use crate::{
     api::TalerRouter,
     auth::AuthMethod,
     constants::MAX_BODY_LENGTH,
     db::TypeHelper as _,
     test::{api::TestApi, db::notification_listener},
 };
 
 mod api;
 mod db;
 
 fn test_api(pool: PgPool, currency: Currency) -> Router {
     let outgoing_channel = Sender::new(0);
     let incoming_channel = Sender::new(0);
     let wg = TestApi {
         currency,
         pool: pool.clone(),
         outgoing_channel: outgoing_channel.clone(),
         incoming_channel: incoming_channel.clone(),
     };
     tokio::spawn(notification_listener(
         pool,
         outgoing_channel,
         incoming_channel,
     ));
     let state = Arc::new(wg);
     Router::new()
         .wire_gateway(state.clone(), AuthMethod::None)
         .prepared_transfer(state.clone())
         .revenue(state, AuthMethod::None)
 }
 
 async fn setup() -> (Router, PgPool) {
     let (_, pool) = db_test_setup_manual("db".as_ref(), "taler-api").await;
     (
         test_api(pool.clone(), "EUR".parse().unwrap()).finalize(),
         pool,
     )
 }
 
 #[tokio::test]
 async fn body_parsing() {
     let (server, _) = setup().await;
     let normal_body = TransferRequest {
         request_uid: Base32::rand(),
         amount: Amount::zero(&Currency::EUR),
         exchange_base_url: url("https://test.com"),
         wtid: Base32::rand(),
         credit_account: payto("payto:://test?receiver-name=lol"),
         metadata: None,
     };
 
     // Check OK
     server
         .post("/taler-wire-gateway/transfer")
         .json(&normal_body)
         .deflate()
         .await
         .assert_ok_json::<TransferResponse>();
 
     // Headers check
     server
         .post("/taler-wire-gateway/transfer")
         .json(&normal_body)
         .remove(header::CONTENT_TYPE)
         .await
         .assert_error_status(
             ErrorCode::GENERIC_HTTP_HEADERS_MALFORMED,
             StatusCode::UNSUPPORTED_MEDIA_TYPE,
         );
     server
         .post("/taler-wire-gateway/transfer")
         .json(&normal_body)
         .deflate()
         .remove(header::CONTENT_ENCODING)
         .await
         .assert_error(ErrorCode::GENERIC_JSON_INVALID);
     server
         .post("/taler-wire-gateway/transfer")
         .json(&normal_body)
         .header(header::CONTENT_TYPE, "invalid")
         .await
         .assert_error_status(
             ErrorCode::GENERIC_HTTP_HEADERS_MALFORMED,
             StatusCode::UNSUPPORTED_MEDIA_TYPE,
         );
     server
         .post("/taler-wire-gateway/transfer")
         .json(&normal_body)
         .header(header::CONTENT_ENCODING, "deflate")
         .await
         .assert_error(ErrorCode::GENERIC_COMPRESSION_INVALID);
     server
         .post("/taler-wire-gateway/transfer")
         .json(&normal_body)
         .header(header::CONTENT_ENCODING, "invalid")
         .await
         .assert_error_status(
             ErrorCode::GENERIC_HTTP_HEADERS_MALFORMED,
             StatusCode::UNSUPPORTED_MEDIA_TYPE,
         );
 
     // Body size limit
     let huge_body = TransferRequest {
         credit_account: payto(format!(
             "payto:://test?message={:A<1$}",
             "payout", MAX_BODY_LENGTH
         )),
         ..normal_body
     };
     server
         .post("/taler-wire-gateway/transfer")
         .json(&huge_body)
         .await
         .assert_error(ErrorCode::GENERIC_UPLOAD_EXCEEDS_LIMIT);
     server
         .post("/taler-wire-gateway/transfer")
         .json(&huge_body)
         .deflate()
         .await
         .assert_error(ErrorCode::GENERIC_UPLOAD_EXCEEDS_LIMIT);
 }
 
 static PAYTO: LazyLock<PaytoURI> = LazyLock::new(|| payto("payto://test?receiver-name=Test"));
 
 #[tokio::test]
 async fn errors() {
     let (server, _) = setup().await;
     server
         .get("/unknown")
         .await
         .assert_error(ErrorCode::GENERIC_ENDPOINT_UNKNOWN);
     server
         .post("/taler-revenue/config")
         .await
         .assert_error(ErrorCode::GENERIC_METHOD_INVALID);
 }
 
 #[tokio::test]
 async fn config() {
     let (server, _) = setup().await;
     server
         .get("/taler-wire-gateway/config")
         .await
         .assert_ok_json::<WireConfig>();
     server
         .get("/taler-prepared-transfer/config")
         .await
         .assert_ok_json::<PreparedTransferConfig>();
     server
         .get("/taler-revenue/config")
         .await
         .assert_ok_json::<RevenueConfig>();
 }
 
 #[tokio::test]
 async fn transfer() {
     let (server, _) = setup().await;
     transfer_routine(&server, TransferState::success, &PAYTO).await;
 }
 
 #[tokio::test]
 async fn outgoing_history() {
     let (server, _) = setup().await;
     routine_pagination::<OutgoingHistory>(
         &server,
         "/taler-wire-gateway/history/outgoing",
         async |i| {
             server
                 .post("/taler-wire-gateway/transfer")
                 .json(json!({
                     "request_uid": HashCode::rand(),
                     "amount": amount(format!("EUR:0.0{i}")),
                     "exchange_base_url": url("http://exchange.taler"),
                     "wtid": ShortHashCode::rand(),
                     "credit_account": PAYTO.clone(),
                 }))
                 .await
                 .assert_ok_json::<TransferResponse>();
         },
     )
     .await;
 }
 
 #[tokio::test]
 async fn admin_add_incoming() {
     let (server, _) = setup().await;
     admin_add_incoming_routine(&server, &PAYTO, true).await;
 }
 
 #[tokio::test]
 async fn in_history() {
     let (server, _) = setup().await;
     in_history_routine(&server, &PAYTO, true).await;
 }
 
 #[tokio::test]
 async fn revenue() {
     let (server, _) = setup().await;
     revenue_routine(&server, &PAYTO, true).await;
 }
 
 #[tokio::test]
 async fn account_check() {
     let (server, _) = setup().await;
     server
         .get("/taler-wire-gateway/account/check")
         .query("account", "payto://test")
         .await
         .assert_status(StatusCode::NOT_IMPLEMENTED);
 }
 
 async fn check_in(pool: &PgPool) -> Vec<Status> {
     sqlx::query(
             "
             SELECT pending_recurrent_in.authorization_pub IS NOT NULL, bounced.tx_in_id IS NOT NULL, type, taler_in.account_pub
             FROM tx_in
                 LEFT JOIN taler_in USING (tx_in_id)
                 LEFT JOIN pending_recurrent_in USING (tx_in_id)
                 LEFT JOIN bounced USING (tx_in_id)
             ORDER BY tx_in.tx_in_id
         ",
         )
         .try_map(|r: PgRow| {
             Ok(
                 if r.try_get_flag(0)? {
                     Status::Pending
                 } else if r.try_get_flag(1)? {
                     Status::Bounced
                 } else {
                     match r.try_get(2)? {
                         None => Status::Simple,
                         Some(IncomingType::reserve) => Status::Reserve(r.try_get(3)?),
                         Some(IncomingType::kyc) => Status::Kyc(r.try_get(3)?),
                         Some(e) => unreachable!("{e:?}")
                     }
                 }
             )
         })
         .fetch_all(pool)
         .await
         .unwrap()
 }
 
 #[tokio::test]
 async fn registration() {
     let (server, pool) = setup().await;
     registration_routine(&server, &PAYTO, || check_in(&pool)).await;
 }