libeufin

main.rs (17426B)

---

 /*
 * This file is part of LibEuFin.
 * Copyright (C) 2026 Taler Systems S.A.
 
 * LibEuFin 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.
 
 * LibEuFin 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 LibEuFin; see the file COPYING.  If not, see
 * <http://www.gnu.org/licenses/>
 */
 
 use std::{
     collections::HashSet,
     fmt::Display,
     path::{Path, PathBuf},
     str::FromStr,
 };
 
 use anyhow::bail;
 use aws_lc_rs::digest::SHA256;
 use clap::{Parser, ValueEnum};
 use globset::{Glob, GlobSetBuilder};
 use jiff::Timestamp;
 use libeufin_ebics::keys::{load_bank_keys, load_client_keys};
 use libeufin_nexus::config::NexusCfg;
 use owo_colors::OwoColorize as _;
 use taler_common::{config::Config, log::taler_logger, types::payto::TransferIbanPayto};
 use taler_test_utils::{cli::clap_parse, repl::Repl};
 use tracing::Level;
 use tracing_subscriber::util::SubscriberInitExt as _;
 use walkdir::WalkDir;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
 enum Component {
     Nexus,
     Ebisync,
 }
 
 impl Component {
     pub async fn run(&self, cfg: &Config, cmd: &str) -> bool {
         match self {
             Component::Nexus => match clap_parse::<libeufin_nexus::Args>(cmd) {
                 Ok(cmd) => {
                     tokio::select! {
                         res = libeufin_nexus::run(cfg, cmd.cmd) => check(res),
                         _ = tokio::signal::ctrl_c() => false
                     }
                 }
                 Err(e) => {
                     println!("Error: {}", e);
                     false
                 }
             },
             Component::Ebisync => match clap_parse::<libeufin_ebisync::Args>(cmd) {
                 Ok(cmd) => {
                     tokio::select! {
                         res = libeufin_ebisync::run(cfg, cmd.cmd) => check(res),
                         _ = tokio::signal::ctrl_c() => false
                     }
                 }
                 Err(e) => {
                     println!("Error: {}", e);
                     false
                 }
             },
         }
     }
 }
 
 #[derive(Parser)]
 /// Run integration tests on banks provider
 pub struct TestbenchCmd {
     #[arg(value_enum)]
     component: Component,
     platform: String,
 }
 
 #[derive(Parser)]
 #[command(no_binary_name = true)]
 /// Run integration tests on banks provider
 pub enum NexusCmd {
     #[clap(alias = "ebics-setup")]
     Setup,
     ResetKeys,
     ResetDb,
     Exit,
     Tx,
     Fetch {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         raw_args: Vec<String>,
     },
     Submit {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         raw_args: Vec<String>,
     },
     List {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         raw_args: Vec<String>,
     },
     Wss,
     TxCheck,
     Import {
         path: PathBuf,
         glob: Vec<Glob>,
     },
     Export {
         path: PathBuf,
     },
     Compact,
 }
 
 #[derive(Parser)]
 #[command(no_binary_name = true)]
 /// Run integration tests on banks provider
 pub enum SyncCmd {
     #[clap(alias = "ebics-setup")]
     Setup,
     ResetKeys,
     ResetDb,
     Exit,
     Fetch {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         raw_args: Vec<String>,
     },
     Testing {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         raw_args: Vec<String>,
     },
     Serve,
     Compact,
 }
 
 fn step(name: impl Display) {
     println!("{}", name.magenta())
 }
 
 fn msg(msg: impl Display) {
     println!("{}", msg.yellow())
 }
 
 fn err(msg: impl Display) {
     println!("{}", msg.red())
 }
 
 fn check<R, E: Display>(res: Result<R, E>) -> bool {
     match &res {
         Ok(_) => println!("{}", "OK".green()),
         Err(e) => {
             tracing::error!(target: "testbench", "{e}");
             err("ERROR")
         }
     };
     res.is_ok()
 }
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     taler_logger(Some(Level::DEBUG), false).init();
     let cmd = TestbenchCmd::parse();
 
     // List available platform
     let platforms: Vec<_> = std::fs::read_dir("testbench/test/platform")
         .unwrap()
         .filter_map(|entry| {
             let e = entry.unwrap();
             let filename = e.file_name();
             if filename == "config.json" {
                 None
             } else {
                 Some(
                     filename
                         .to_string_lossy()
                         .strip_suffix(".conf")
                         .unwrap()
                         .to_owned(),
                 )
             }
         })
         .collect();
     if !platforms.contains(&cmd.platform) {
         bail!(
             "Unknown platform '{}', expected one of {}",
             cmd.platform,
             platforms.join(", ")
         );
     }
 
     // Augment config
     let simple_cfg =
         std::fs::read_to_string(format!("testbench/test/platform/{}.conf", cmd.platform)).unwrap();
     let cfg = Config::from_mem_with_env(
         match cmd.component {
             Component::Nexus => libeufin_nexus::constants::CONFIG_SOURCE,
             Component::Ebisync => libeufin_ebisync::constants::CONFIG_SOURCE
         }
         , &format!(
             r#"
         {simple_cfg}
         {}
         [paths]
         LIBEUFIN_NEXUS_HOME = testbench/test/{}
         EBISYNC_HOME = testbench/test/{}
 
         [nexus-fetch]
         FREQUENCY = 1h
         CHECKPOINT_TIME_OF_DAY = 16:52
 
         [ebisync-fetch]
         FREQUENCY = 1h
         CHECKPOINT_TIME_OF_DAY = 16:52
         DESTINATION = azure-blob-storage
         AZURE_API_URL = http://localhost:10000/devstoreaccount1/
         AZURE_ACCOUNT_NAME = devstoreaccount1
         AZURE_ACCOUNT_KEY = Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==
         AZURE_CONTAINER = test
 
         [ebisync-submit]
         SOURCE = ebisync-api
         AUTH_METHOD = none
 
         [libeufin-nexusdb-postgres]
         CONFIG = postgres:///libeufintestbench
 
         [ebisyncdb-postgres]
         CONFIG = postgres:///libeufintestbench
     "#,
             simple_cfg
                 .replace("[nexus-ebics]", "[ebisync]")
                 .replace("[nexus-setup]", "[ebisync-setup]"),
             cmd.platform,
             cmd.platform
         )).unwrap();
     let cfg = NexusCfg::parse(&cfg).unwrap();
     let ebics = cfg.keys().unwrap();
     let (name, settings) = match cfg.host().unwrap().base_url.as_str() {
         "https://isotest.postfinance.ch/ebicsweb/ebicsweb" => (
             "PostFinance IsoTest",
             Some("https://isotest.postfinance.ch/corporates/user/settings/ebics"),
         ),
         "https://iso20022test.credit-suisse.com/ebicsweb/ebicsweb" => (
             "Credit Suisse isoTest",
             Some("https://iso20022test.credit-suisse.com/user/settings/ebics"),
         ),
         "https://ebics.postfinance.ch/ebics/ebics.aspx" => ("PostFinance", None),
         _ => ("Unknown", None),
     };
     let test = settings.is_some();
     let payto = match cfg.currency.as_ref() {
         "CHF" => {
             "payto://iban/GENODED1SPW/DE48330605920000686018?receiver-name=Christian%20Grothoff"
         }
         "EUR" => {
             "payto://iban/GENODED1SPW/DE48330605920000686018?receiver-name=Christian%20Grothoff"
         }
         _ => todo!("{}", cfg.currency),
     };
     let payto = TransferIbanPayto::from_str(payto).unwrap();
     let ebics_log = format!("--debug-ebics testbench/test/{}", cmd.platform);
     let run = async |args: &str| cmd.component.run(&cfg.cfg, args).await;
     let auto_setup = async || {
         let client = load_client_keys(ebics.client.as_ref()).unwrap();
         let bank = load_bank_keys(ebics.bank.as_ref()).unwrap();
         if settings.is_none() && client.is_none() {
             msg("Manual setup is required for non test environment")
         } else if client
             .map(|it| !it.submitted_ini || !it.submitted_hia)
             .unwrap_or(true)
             || bank.map(|it| !it.accepted).unwrap_or(true)
         {
             step("Run EBICS setup");
             if !run(&format!("ebics-setup {ebics_log}")).await {
                 if let Some(settings) = settings {
                     let client = load_client_keys(ebics.client.as_ref()).unwrap();
                     if client
                         .map(|it| !it.submitted_ini || !it.submitted_hia)
                         .unwrap_or(true)
                     {
                         msg(format_args!(
                             "Got to {settings} and click on 'Reset EBICS user'"
                         ))
                     } else {
                         msg(format_args!(
                             "Got to {settings} and click on 'Activate EBICS user'"
                         ))
                     }
                 } else {
                     msg("Activate your keys at your bank")
                 }
             }
         }
     };
     msg(format!("Init {name}"));
     run("dbinit").await;
 
     let platform = cmd.platform;
     let prompt = format!("{:?} {platform} {name}", cmd.component);
 
     match cmd.component {
         Component::Nexus => {
             let mut repl = Repl::new(".nexus_history");
             auto_setup().await;
             while let Some(cmd) = repl.read_line(&prompt, "") {
                 match cmd {
                     NexusCmd::Setup => {
                         run(&format!("ebics-setup {ebics_log}")).await;
                     }
                     NexusCmd::ResetDb => {
                         run("dbinit -r").await;
                     }
                     NexusCmd::Compact => {
                         compact(format!("testbench/test/{platform}"));
                     }
                     NexusCmd::Fetch { raw_args } => {
                         run(&format!("ebics-fetch {ebics_log} {}", raw_args.join(" "))).await;
                     }
                     NexusCmd::Submit { raw_args } => {
                         run(&format!("ebics-submit {ebics_log} {}", raw_args.join(" "))).await;
                     }
                     NexusCmd::Tx => {
                         run(&format!(
                             "initiate-payment --amount={}:0.1 --subject=\"single {}\" {payto}",
                             cfg.currency,
                             Timestamp::now()
                         ))
                         .await;
                     }
                     NexusCmd::List { raw_args } => {
                         run(&format!("list {}", raw_args.join(" "))).await;
                     }
                     NexusCmd::ResetKeys => {
                         if test && std::fs::exists(&ebics.client).unwrap() {
                             std::fs::remove_file(&ebics.client).unwrap();
                         }
                         if std::fs::exists(&ebics.bank).unwrap() {
                             std::fs::remove_file(&ebics.bank).unwrap();
                         }
                     }
                     NexusCmd::TxCheck => {
                         run(&format!("testing tx-check {ebics_log}")).await;
                     }
                     NexusCmd::Wss => {
                         run(&format!("testing wss {ebics_log}")).await;
                     }
                     NexusCmd::Import { path, glob } => {
                         let mut b = GlobSetBuilder::new();
                         for glob in glob {
                             b.add(glob);
                         }
                         let matcher = b.build().unwrap();
                         let mut paths = Vec::new();
                         for entry in WalkDir::new(&path).into_iter().filter_map(Result::ok) {
                             let entry = entry.path();
 
                             // usually match against relative path
                             let rel = entry.strip_prefix(&path).unwrap_or(entry);
 
                             if matcher.is_match(rel) {
                                 paths.push(entry.to_string_lossy().to_string());
                             }
                         }
 
                         run(&format!("manual import {}", paths.join(" "))).await;
                     }
                     NexusCmd::Export { path } => {
                         run(&format!("manual export {}", path.to_string_lossy())).await;
                     }
                     NexusCmd::Exit => break,
                 }
             }
         }
         Component::Ebisync => {
             let mut repl = Repl::new(".ebisync_history");
             auto_setup().await;
             while let Some(cmd) = repl.read_line(&prompt, "") {
                 match cmd {
                     SyncCmd::Compact => {
                         compact(format!("testbench/test/{platform}"));
                     }
                     SyncCmd::Setup => {
                         run(&format!("setup {ebics_log}")).await;
                     }
                     SyncCmd::ResetDb => {
                         run("dbinit -r").await;
                     }
                     SyncCmd::Fetch { raw_args } => {
                         run(&format!("fetch {ebics_log} {}", raw_args.join(" "))).await;
                     }
                     SyncCmd::Testing { raw_args } => {
                         run(&format!("testing {}", raw_args.join(" "))).await;
                     }
                     SyncCmd::Serve => {
                         run("serve").await;
                     }
                     SyncCmd::ResetKeys => {
                         if test {
                             std::fs::remove_file(&ebics.client).unwrap();
                         }
                         std::fs::remove_file(&ebics.bank).unwrap();
                     }
                     SyncCmd::Exit => break,
                 }
             }
         }
     }
     Ok(())
 }
 
 /// Remove duplicated files and empty dir
 fn compact(p: String) {
     /// Announce and recursively remove file or directory
     fn remove(p: &Path, reason: &str) {
         println!("rm {} {}", reason, p.display());
         if p.is_dir() {
             std::fs::remove_dir_all(p).unwrap();
         } else {
             std::fs::remove_file(p).unwrap()
         }
     }
 
     /// Collect directory entries into a Vec upfront
     /// and avoids surprises from mutating a directory while iterating it).
     fn read_dir_paths(dir: &Path) -> Vec<PathBuf> {
         let mut v = Vec::new();
         for entry in std::fs::read_dir(dir).unwrap() {
             v.push(entry.unwrap().path());
         }
         v
     }
 
     fn is_dir_empty(dir: &Path) -> bool {
         std::fs::read_dir(dir).unwrap().next().is_none()
     }
 
     /// Delete file if another file has the same (whitespace-stripped) content
     fn rm_if_similar(p: &Path, content: &str, content_hashes: &mut HashSet<Vec<u8>>) {
         let normalized: String = content.chars().filter(|c| c.is_whitespace()).collect();
 
         let digest = aws_lc_rs::digest::digest(&SHA256, normalized.as_bytes());
 
         if content_hashes.contains(digest.as_ref()) {
             remove(p, "similar");
         } else {
             content_hashes.insert(digest.as_ref().to_vec());
         }
     }
 
     fn file_name_str(p: &Path) -> String {
         p.file_name()
             .map(|n| n.to_string_lossy().into_owned())
             .unwrap_or_default()
     }
 
     let mut content_hashes: HashSet<Vec<u8>> = HashSet::new();
 
     for date in read_dir_paths(p.as_ref()) {
         if !date.is_dir() {
             continue;
         }
 
         for request in read_dir_paths(&date) {
             let payload_file_path = request.join("payload.xml");
             let payload_dir_path = request.join("payload");
             let request_name = file_name_str(&request);
 
             if payload_file_path.exists() {
                 let content = std::fs::read_to_string(&payload_file_path).unwrap();
 
                 if request_name.contains("HAC") && !content.contains("ORDER_HAC_FINAL_NEG") {
                     remove(&request, "simple hac");
                 } else if request_name.contains("HAA") && !content.contains("<Service>") {
                     remove(&request, "empty haa");
                 } else if request_name.contains("wssparam") {
                     remove(&request, "wssparam");
                 } else {
                     rm_if_similar(&payload_file_path, &content, &mut content_hashes);
                 }
             } else if payload_dir_path.exists() {
                 for file in read_dir_paths(&payload_dir_path) {
                     let content = std::fs::read_to_string(&file).unwrap();
                     rm_if_similar(&file, &content, &mut content_hashes);
                 }
                 if is_dir_empty(&payload_dir_path) {
                     remove(&request, "empty payload");
                 }
             }
             if request.exists() && !payload_file_path.exists() && !payload_dir_path.exists() {
                 remove(&request, "empty request");
             }
         }
 
         if is_dir_empty(&date) {
             remove(&date, "empty dir");
         }
     }
 }