taler-rust

routine.rs (18874B)

---

 /*
   This file is part of TALER
   Copyright (C) 2024-2025 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::{
     borrow::Cow,
     fmt::Debug,
     future::Future,
     time::{Duration, Instant},
 };
 
 use axum::Router;
 use serde::{Deserialize, de::DeserializeOwned};
 use taler_api::db::IncomingType;
 use taler_common::{
     api_common::{EddsaPublicKey, HashCode, ShortHashCode},
     api_params::PageParams,
     api_revenue::RevenueIncomingHistory,
     api_wire::{
         IncomingBankTransaction, IncomingHistory, TransferList, TransferResponse, TransferState,
         TransferStatus,
     },
     error_code::ErrorCode,
     types::{amount::amount, base32::Base32, payto::PaytoURI, url},
 };
 use tokio::time::sleep;
 
 use crate::{
     json,
     server::{TestResponse, TestServer as _},
 };
 
 pub async fn routine_pagination<'a, T: DeserializeOwned, F: Future<Output = ()>>(
     server: &'a Router,
     url: &str,
     ids: fn(T) -> Vec<i64>,
     mut register: impl FnMut(&'a Router, usize) -> F,
 ) {
     // Check supported
     if !server.get(url).await.is_implemented() {
         return;
     }
 
     // Check history is following specs
     let assert_history = |args: Cow<'static, str>, size: usize| async move {
         let resp = server.get(&format!("{url}?{args}")).await;
         assert_history_ids(&resp, ids, size)
     };
     // Get latest registered id
     let latest_id = || async move { assert_history("limit=-1".into(), 1).await[0] };
 
     for i in 0..20 {
         register(server, i).await;
     }
 
     let id = latest_id().await;
 
     // default
     assert_history("".into(), 20).await;
 
     // forward range
     assert_history("limit=10".into(), 10).await;
     assert_history("limit=10&offset=4".into(), 10).await;
 
     // backward range
     assert_history("limit=-10".into(), 10).await;
     assert_history(format!("limit=-10&{}", id - 4).into(), 10).await;
 }
 
 pub async fn assert_time<R: Debug>(range: std::ops::Range<u128>, task: impl Future<Output = R>) {
     let start = Instant::now();
     task.await;
     let elapsed = start.elapsed().as_millis();
     if !range.contains(&elapsed) {
         panic!("Expected to last {range:?} got {elapsed:?}")
     }
 }
 
 pub async fn routine_history<
     'a,
     T: DeserializeOwned,
     FR: Future<Output = ()>,
     FI: Future<Output = ()>,
 >(
     server: &'a Router,
     url: &str,
     ids: fn(T) -> Vec<i64>,
     nb_register: usize,
     mut register: impl FnMut(&'a Router, usize) -> FR,
     nb_ignore: usize,
     mut ignore: impl FnMut(&'a Router, usize) -> FI,
 ) {
     // Check history is following specs
     macro_rules! assert_history {
         ($args:expr, $size:expr) => {
             async {
                 let resp = server.get(&format!("{url}?{}", $args)).await;
                 assert_history_ids(&resp, ids, $size)
             }
         };
     }
     // Get latest registered id
     let latest_id = || async { assert_history!("limit=-1", 1).await[0] };
 
     // Check error when no transactions
     assert_history!("limit=7".to_owned(), 0).await;
 
     let mut register_iter = (0..nb_register).peekable();
     let mut ignore_iter = (0..nb_ignore).peekable();
     while register_iter.peek().is_some() || ignore_iter.peek().is_some() {
         if let Some(idx) = register_iter.next() {
             register(server, idx).await
         }
         if let Some(idx) = ignore_iter.next() {
             ignore(server, idx).await
         }
     }
     let nb_total = nb_register + nb_ignore;
 
     // Check ignored
     assert_history!(format_args!("limit={nb_total}"), nb_register).await;
     // Check skip ignored
     assert_history!(format_args!("limit={nb_register}"), nb_register).await;
 
     // Check no polling when we cannot have more transactions
     assert_time(
         0..100,
         assert_history!(
             format_args!("limit=-{}&timeout_ms=1000", nb_register + 1),
             nb_register
         ),
     )
     .await;
     // Check no polling when already find transactions even if less than delta
     assert_time(
         0..100,
         assert_history!(
             format_args!("limit={}&timeout_ms=1000", nb_register + 1),
             nb_register
         ),
     )
     .await;
 
     // Check polling
     let id = latest_id().await;
     tokio::join!(
         // Check polling succeed
         assert_time(
             100..300,
             assert_history!(format_args!("limit=2&offset={id}&timeout_ms=1000"), 1)
         ),
         assert_time(
             200..300,
             assert_history!(
                 format_args!(
                     "limit=1&offset={}&timeout_ms=200",
                     id as usize + nb_total * 3
                 ),
                 0
             )
         ),
         async {
             sleep(Duration::from_millis(100)).await;
             register(server, 0).await
         }
     );
 
     // Test triggers
     for i in 0..nb_register {
         let id = latest_id().await;
         tokio::join!(
             // Check polling succeed
             assert_time(
                 100..300,
                 assert_history!(format_args!("limit=7&offset={id}&timeout_ms=1000"), 1)
             ),
             async {
                 sleep(Duration::from_millis(100)).await;
                 register(server, i).await
             }
         );
     }
 
     // Test doesn't trigger
     let id = latest_id().await;
     tokio::join!(
         // Check polling succeed
         assert_time(
             200..300,
             assert_history!(format_args!("limit=7&offset={id}&timeout_ms=200"), 0)
         ),
         async {
             sleep(Duration::from_millis(100)).await;
             for i in 0..nb_ignore {
                 ignore(server, i).await
             }
         }
     );
 
     routine_pagination(server, url, ids, register).await;
 }
 
 #[track_caller]
 fn assert_history_ids<'de, T: Deserialize<'de>>(
     resp: &'de TestResponse,
     ids: impl Fn(T) -> Vec<i64>,
     size: usize,
 ) -> Vec<i64> {
     if size == 0 {
         resp.assert_no_content();
         return vec![];
     }
     let body = resp.assert_ok_json::<T>();
     let history: Vec<_> = ids(body);
     let params = resp.query::<PageParams>().check(1024).unwrap();
 
     // testing the size is like expected
     assert_eq!(size, history.len(), "bad history length: {history:?}");
     if params.limit < 0 {
         // testing that the first id is at most the 'offset' query param.
         assert!(
             params
                 .offset
                 .map(|offset| history[0] <= offset)
                 .unwrap_or(true),
             "bad history offset: {params:?} {history:?}"
         );
         // testing that the id decreases.
         assert!(
             history.as_slice().is_sorted_by(|a, b| a > b),
             "bad history order: {history:?}"
         )
     } else {
         // testing that the first id is at least the 'offset' query param.
         assert!(
             params
                 .offset
                 .map(|offset| history[0] >= offset)
                 .unwrap_or(true),
             "bad history offset: {params:?} {history:?}"
         );
         // testing that the id increases.
         assert!(
             history.as_slice().is_sorted(),
             "bad history order: {history:?}"
         )
     }
     history
 }
 
 // Get currency from config
 async fn get_currency(server: &Router) -> String {
     let config = server
         .get("/taler-wire-gateway/config")
         .await
         .assert_ok_json::<serde_json::Value>();
     let currency = config["currency"].as_str().unwrap();
     currency.to_owned()
 }
 
 /// Test standard behavior of the transfer endpoints
 pub async fn transfer_routine(
     server: &Router,
     default_status: TransferState,
     credit_account: &PaytoURI,
 ) {
     let currency = &get_currency(server).await;
     let default_amount = amount(format!("{currency}:42"));
     let transfer_request = json!({
         "request_uid": HashCode::rand(),
         "amount": default_amount,
         "exchange_base_url": "http://exchange.taler/",
         "wtid": ShortHashCode::rand(),
         "credit_account": credit_account,
     });
 
     // Check empty db
     {
         server
             .get("/taler-wire-gateway/transfers")
             .await
             .assert_no_content();
         server
             .get(&format!(
                 "/taler-wire-gateway/transfers?status={}",
                 default_status.as_ref()
             ))
             .await
             .assert_no_content();
     }
 
     // Check create transfer
     {
         // Check OK
         let first = server
             .post("/taler-wire-gateway/transfer")
             .json(&transfer_request)
             .await
             .assert_ok_json::<TransferResponse>();
         // Check idempotent
         let second = server
             .post("/taler-wire-gateway/transfer")
             .json(&transfer_request)
             .await
             .assert_ok_json::<TransferResponse>();
         assert_eq!(first.row_id, second.row_id);
         assert_eq!(first.timestamp, second.timestamp);
 
         // Check request uid reuse
         server
             .post("/taler-wire-gateway/transfer")
             .json(&json!(transfer_request + {
                 "wtid": ShortHashCode::rand()
             }))
             .await
             .assert_error(ErrorCode::BANK_TRANSFER_REQUEST_UID_REUSED);
         // Check wtid reuse
         server
             .post("/taler-wire-gateway/transfer")
             .json(&json!(transfer_request + {
                 "request_uid": HashCode::rand(),
             }))
             .await
             .assert_error(ErrorCode::BANK_TRANSFER_WTID_REUSED);
 
         // Check currency mismatch
         server
             .post("/taler-wire-gateway/transfer")
             .json(&json!(transfer_request + {
                 "amount": "BAD:42"
             }))
             .await
             .assert_error(ErrorCode::GENERIC_CURRENCY_MISMATCH);
     }
 
     // Check transfer by id
     {
         let wtid = ShortHashCode::rand();
         let resp = server
             .post("/taler-wire-gateway/transfer")
             .json(&json!(transfer_request + {
                 "request_uid": HashCode::rand(),
                 "wtid": wtid,
             }))
             .await
             .assert_ok_json::<TransferResponse>();
 
         // Check OK
         let tx = server
             .get(&format!("/taler-wire-gateway/transfers/{}", resp.row_id))
             .await
             .assert_ok_json::<TransferStatus>();
         assert_eq!(default_status, tx.status);
         assert_eq!(default_amount, tx.amount);
         assert_eq!("http://exchange.taler/", tx.origin_exchange_url);
         assert_eq!(wtid, tx.wtid);
         assert_eq!(resp.timestamp, tx.timestamp);
 
         // Check unknown transaction
         server
             .get("/taler-wire-gateway/transfers/42")
             .await
             .assert_error(ErrorCode::BANK_TRANSACTION_NOT_FOUND);
     }
 
     // Check transfer page
     {
         for _ in 0..4 {
             server
                 .post("/taler-wire-gateway/transfer")
                 .json(&json!(transfer_request + {
                     "request_uid": HashCode::rand(),
                     "wtid": ShortHashCode::rand(),
                 }))
                 .await
                 .assert_ok_json::<TransferResponse>();
         }
         {
             let list = server
                 .get("/taler-wire-gateway/transfers")
                 .await
                 .assert_ok_json::<TransferList>();
             assert_eq!(list.transfers.len(), 6);
             assert_eq!(
                 list,
                 server
                     .get(&format!(
                         "/taler-wire-gateway/transfers?status={}",
                         default_status.as_ref()
                     ))
                     .await
                     .assert_ok_json::<TransferList>()
             )
         }
 
         // Pagination test
         routine_pagination::<TransferList, _>(
             server,
             "/taler-wire-gateway/transfers",
             |it| {
                 it.transfers
                     .into_iter()
                     .map(|it| *it.row_id as i64)
                     .collect()
             },
             |server, i| async move {
                 server
                     .post("/taler-wire-gateway/transfer")
                     .json(&json!({
                         "request_uid": HashCode::rand(),
                         "amount": amount(format!("{currency}:0.0{i}")),
                         "exchange_base_url": url("http://exchange.taler"),
                         "wtid": ShortHashCode::rand(),
                         "credit_account": credit_account,
                     }))
                     .await
                     .assert_ok_json::<TransferResponse>();
             },
         )
         .await;
     }
 }
 
 async fn add_incoming_routine(
     server: &Router,
     currency: &str,
     kind: IncomingType,
     debit_acount: &PaytoURI,
 ) {
     let (path, key) = match kind {
         IncomingType::reserve => ("/taler-wire-gateway/admin/add-incoming", "reserve_pub"),
         IncomingType::kyc => ("/taler-wire-gateway/admin/add-kycauth", "account_pub"),
         IncomingType::wad => unreachable!(),
     };
     let valid_req = json!({
         "amount": format!("{currency}:44"),
         key: EddsaPublicKey::rand(),
         "debit_account": debit_acount,
     });
 
     // Check OK
     server.post(path).json(&valid_req).await.assert_ok();
 
     match kind {
         IncomingType::reserve => {
             // Trigger conflict due to reused reserve_pub
             server
                 .post(path)
                 .json(&json!(valid_req + {
                     "amount": format!("{currency}:44.1"),
                 }))
                 .await
                 .assert_error(ErrorCode::BANK_DUPLICATE_RESERVE_PUB_SUBJECT)
         }
         IncomingType::kyc => {
             // Non conflict on reuse
             server.post(path).json(&valid_req).await.assert_ok();
         }
         IncomingType::wad => unreachable!(),
     }
 
     // Currency mismatch
     server
         .post(path)
         .json(&json!(valid_req + {
             "amount": "BAD:33"
         }))
         .await
         .assert_error(ErrorCode::GENERIC_CURRENCY_MISMATCH);
 
     // Bad BASE32 reserve_pub
     server
         .post(path)
         .json(&json!(valid_req + {
             key: "I love chocolate"
         }))
         .await
         .assert_error(ErrorCode::GENERIC_JSON_INVALID);
 
     server
         .post(path)
         .json(&json!(valid_req + {
             key: Base32::<31>::rand()
         }))
         .await
         .assert_error(ErrorCode::GENERIC_JSON_INVALID);
 
     // Bad payto kind
     server
         .post(path)
         .json(&json!(valid_req + {
             "debit_account": "http://email@test.com"
         }))
         .await
         .assert_error(ErrorCode::GENERIC_JSON_INVALID);
 }
 
 /// Test standard behavior of the revenue endpoints
 pub async fn revenue_routine(server: &Router, debit_acount: &PaytoURI, kyc: bool) {
     let currency = &get_currency(server).await;
 
     routine_history(
         server,
         "/taler-revenue/history",
         |it: RevenueIncomingHistory| {
             it.incoming_transactions
                 .into_iter()
                 .map(|it| *it.row_id as i64)
                 .collect()
         },
         2,
         |server, i| async move {
             if i % 2 == 0 || !kyc {
                 server
                     .post("/taler-wire-gateway/admin/add-incoming")
                     .json(&json!({
                         "amount": format!("{currency}:0.0{i}"),
                         "reserve_pub": EddsaPublicKey::rand(),
                         "debit_account": debit_acount,
                     }))
                     .await
                     .assert_ok_json::<TransferResponse>();
             } else {
                 server
                     .post("/taler-wire-gateway/admin/add-kycauth")
                     .json(&json!({
                         "amount": format!("{currency}:0.0{i}"),
                         "account_pub": EddsaPublicKey::rand(),
                         "debit_account": debit_acount,
                     }))
                     .await
                     .assert_ok_json::<TransferResponse>();
             }
         },
         0,
         |_, _| async move {},
     )
     .await;
 }
 
 /// Test standard behavior of the admin add incoming endpoints
 pub async fn admin_add_incoming_routine(server: &Router, debit_acount: &PaytoURI, kyc: bool) {
     let currency = &get_currency(server).await;
 
     // History
     // TODO check non taler some are ignored
     routine_history(
         server,
         "/taler-wire-gateway/history/incoming",
         |it: IncomingHistory| {
             it.incoming_transactions
                 .into_iter()
                 .map(|it| match it {
                     IncomingBankTransaction::Reserve { row_id, .. }
                     | IncomingBankTransaction::Wad { row_id, .. }
                     | IncomingBankTransaction::Kyc { row_id, .. } => *row_id as i64,
                 })
                 .collect()
         },
         2,
         |server, i| async move {
             if i % 2 == 0 || !kyc {
                 server
                     .post("/taler-wire-gateway/admin/add-incoming")
                     .json(&json!({
                         "amount": format!("{currency}:0.0{i}"),
                         "reserve_pub": EddsaPublicKey::rand(),
                         "debit_account": debit_acount,
                     }))
                     .await
                     .assert_ok_json::<TransferResponse>();
             } else {
                 server
                     .post("/taler-wire-gateway/admin/add-kycauth")
                     .json(&json!({
                         "amount": format!("{currency}:0.0{i}"),
                         "account_pub": EddsaPublicKey::rand(),
                         "debit_account": debit_acount,
                     }))
                     .await
                     .assert_ok_json::<TransferResponse>();
             }
         },
         0,
         |_, _| async move {},
     )
     .await;
     // Add incoming reserve
     add_incoming_routine(server, currency, IncomingType::reserve, debit_acount).await;
     if kyc {
         // Add incoming kyc
         add_incoming_routine(server, currency, IncomingType::kyc, debit_acount).await;
     }
 }