taler-rust

api.rs (5122B)

---

 /*
   This file is part of TALER
   Copyright (C) 2024, 2025, 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::sync::LazyLock;
 
 use axum::http::StatusCode;
 use common::setup;
 use sqlx::{PgPool, Row, postgres::PgRow};
 use taler_api::db::TypeHelper as _;
 use taler_common::{
     api_common::{HashCode, ShortHashCode},
     api_revenue::RevenueConfig,
     api_transfer::PreparedTransferConfig,
     api_wire::{OutgoingHistory, TransferResponse, TransferState, WireConfig},
     db::IncomingType,
     error_code::ErrorCode,
     types::{
         amount::amount,
         payto::{PaytoURI, payto},
         url,
     },
 };
 use taler_test_utils::{
     json,
     routine::{
         Status, admin_add_incoming_routine, in_history_routine, registration_routine,
         revenue_routine, routine_pagination, transfer_routine,
     },
     server::TestServer as _,
 };
 
 mod common;
 
 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;
 }