taler-rust

api.rs (6348B)

---

 /*
   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 axum::http::StatusCode;
 use common::setup;
 use jiff::Timestamp;
 use sqlx::{PgPool, Row, postgres::PgRow};
 use taler_api::db::TypeHelper as _;
 use taler_common::{
     api_common::{EddsaPublicKey, HashCode, ShortHashCode},
     api_revenue::RevenueConfig,
     api_transfer::WireTransferConfig,
     api_wire::{OutgoingHistory, TransferResponse, TransferState, WireConfig},
     db::IncomingType,
     error_code::ErrorCode,
     types::{amount::amount, payto::payto, url},
 };
 use taler_test_utils::{
     json,
     routine::{
         Status, admin_add_incoming_routine, registration_routine, revenue_routine,
         routine_pagination, transfer_routine,
     },
     server::TestServer as _,
 };
 use tracing::warn;
 
 use crate::common::db::{AddIncomingResult, add_incoming};
 
 mod common;
 
 #[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-wire-transfer-gateway/config")
         .await
         .assert_ok_json::<WireTransferConfig>();
     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("payto://test")).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": url("payto://test"),
                 }))
                 .await
                 .assert_ok_json::<TransferResponse>();
         },
     )
     .await;
 }
 
 #[tokio::test]
 async fn admin_add_incoming() {
     let (server, _) = setup().await;
     admin_add_incoming_routine(&server, &payto("payto://test"), true).await;
 }
 
 #[tokio::test]
 async fn revenue() {
     let (server, _) = setup().await;
     revenue_routine(&server, &payto("payto://test"), 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()
 }
 
 async fn register_mapped(pool: &PgPool, account_pub: &EddsaPublicKey) {
     let reason = match add_incoming(
         pool,
         &amount("EUR:42"),
         &payto("payto://test"),
         "lol",
         &Timestamp::now(),
         IncomingType::map,
         account_pub,
     )
     .await
     .unwrap()
     {
         AddIncomingResult::Success { .. } => return,
         AddIncomingResult::ReservePubReuse => "reserve pub reuse",
         AddIncomingResult::UnknownMapping => "unknown mapping",
         AddIncomingResult::MappingReuse => "mapping reuse",
     };
     warn!("Bounce {reason}");
     sqlx::query(
         "
             WITH tx_in AS (
                 INSERT INTO tx_in (
                     amount,
                     debit_payto,
                     created_at,
                     subject
                 ) VALUES (
                     (32, 0),
                     'payto',
                     0,
                     'subject'
                 ) RETURNING tx_in_id
             )
             INSERT INTO bounced (tx_in_id)
             SELECT tx_in_id FROM tx_in
         ",
     )
     .execute(pool)
     .await
     .unwrap();
 }
 
 #[tokio::test]
 async fn registration() {
     let (server, pool) = setup().await;
     registration_routine(
         &server,
         &payto("payto://test"),
         || check_in(&pool),
         |account_pub| {
             let account_pub = account_pub.clone();
             let pool = &pool;
             async move { register_mapped(pool, &account_pub).await }
         },
     )
     .await;
 }