taler-rust

server.rs (7460B)

---

 /*
   This file is part of TALER
   Copyright (C) 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::{fmt::Debug, io::Write, pin::Pin};
 
 use axum::{
     Router,
     body::{Body, Bytes},
     extract::Query,
     http::{
         HeaderMap, HeaderValue, Method, StatusCode, Uri,
         header::{self, AsHeaderName, IntoHeaderName},
     },
 };
 use flate2::{Compression, write::ZlibEncoder};
 use http_body_util::BodyExt as _;
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use taler_common::{api_common::ErrorDetail, error_code::ErrorCode};
 use tower::ServiceExt as _;
 use tracing::warn;
 use url::Url;
 
 pub trait TestServer {
     fn method(&self, method: Method, path: &str) -> TestRequest;
 
     fn get(&self, path: &str) -> TestRequest {
         self.method(Method::GET, path)
     }
 
     fn post(&self, path: &str) -> TestRequest {
         self.method(Method::POST, path)
     }
 }
 
 impl TestServer for Router {
     fn method(&self, method: Method, path: &str) -> TestRequest {
         let url = format!("https://example{path}");
         TestRequest {
             router: self.clone(),
             method,
             url: url.parse().unwrap(),
             body: None,
             headers: HeaderMap::new(),
         }
     }
 }
 
 pub struct TestRequest {
     router: Router,
     method: Method,
     url: Url,
     body: Option<Vec<u8>>,
     headers: HeaderMap,
 }
 
 impl TestRequest {
     #[track_caller]
     pub fn query<T: Serialize>(mut self, k: &str, v: T) -> Self {
         let mut pairs = self.url.query_pairs_mut();
         let serializer = serde_urlencoded::Serializer::new(&mut pairs);
         [(k, v)].serialize(serializer).unwrap();
         drop(pairs);
         self
     }
 
     pub fn json<T: Serialize>(mut self, body: &T) -> Self {
         assert!(self.body.is_none());
         let bytes = serde_json::to_vec(body).unwrap();
         self.body = Some(bytes);
         self.headers.insert(
             header::CONTENT_TYPE,
             HeaderValue::from_static("application/json"),
         );
         self
     }
 
     pub fn deflate(mut self) -> Self {
         let body = self.body.unwrap();
         let mut encoder = ZlibEncoder::new(Vec::new(), Compression::fast());
         encoder.write_all(&body).unwrap();
         let compressed = encoder.finish().unwrap();
         self.body = Some(compressed);
         self.headers.insert(
             header::CONTENT_ENCODING,
             HeaderValue::from_static("deflate"),
         );
         self
     }
 
     pub fn remove(mut self, k: impl AsHeaderName) -> Self {
         self.headers.remove(k);
         self
     }
 
     pub fn header<V>(mut self, k: impl IntoHeaderName, v: V) -> Self
     where
         V: TryInto<HeaderValue>,
         V::Error: Debug,
     {
         self.headers.insert(k, v.try_into().unwrap());
         self
     }
 
     async fn send(self) -> TestResponse {
         let TestRequest {
             router,
             method,
             url: uri,
             body,
             headers,
         } = self;
         let uri = Uri::try_from(uri.as_str()).unwrap();
         let mut builder = axum::http::request::Builder::new()
             .method(&method)
             .uri(&uri);
         for (k, v) in headers {
             if let Some(k) = k {
                 builder = builder.header(k, v);
             } else {
                 builder = builder.header("", v);
             }
         }
 
         let resp = router
             .oneshot(builder.body(Body::from(body.unwrap_or_default())).unwrap())
             .await
             .unwrap();
         let (parts, body) = resp.into_parts();
         let bytes = body.collect().await.unwrap();
         TestResponse {
             bytes: bytes.to_bytes(),
             method,
             status: parts.status,
             uri,
         }
     }
 }
 
 impl IntoFuture for TestRequest {
     type Output = TestResponse;
     type IntoFuture = Pin<Box<dyn Future<Output = Self::Output>>>;
 
     fn into_future(self) -> Self::IntoFuture {
         Box::pin(self.send())
     }
 }
 
 pub struct TestResponse {
     bytes: Bytes,
     method: Method,
     uri: Uri,
     status: StatusCode,
 }
 
 impl TestResponse {
     #[track_caller]
     pub fn is_implemented(&self) -> bool {
         if self.status == StatusCode::NOT_IMPLEMENTED {
             let err: ErrorDetail = self.json_parse();
             warn!(
                 "{} is not implemented: {}",
                 self.uri.path(),
                 err.hint.unwrap_or_default()
             );
             false
         } else {
             true
         }
     }
 
     #[track_caller]
     pub fn json_parse<'de, T: Deserialize<'de>>(&'de self) -> T {
         let TestResponse {
             status,
             bytes,
             method,
             uri,
         } = self;
         match serde_json::from_slice(bytes) {
             Ok(body) => body,
             Err(err) => match serde_json::from_slice::<serde_json::Value>(bytes) {
                 Ok(raw) => panic!("{method} {uri} {status} invalid JSON schema: {err}\n{raw}"),
                 Err(err) => panic!(
                     "{method} {uri} {status} invalid JSON body: {err}\n{}",
                     String::from_utf8_lossy(bytes)
                 ),
             },
         }
     }
 
     #[track_caller]
     pub fn assert_status(&self, expected: StatusCode) {
         let TestResponse {
             status,
             bytes,
             method,
             uri,
         } = self;
         if expected != *status {
             if status.is_success() || bytes.is_empty() {
                 panic!("{method} {uri} expected {expected} got {status}");
             } else {
                 let err: ErrorDetail = self.json_parse();
                 let description = err.hint.unwrap_or_default();
                 panic!(
                     "{method} {uri} expected {expected} got {status}: {} {description}",
                     err.code
                 );
             }
         }
     }
 
     #[track_caller]
     pub fn assert_ok_json<'de, T: Deserialize<'de>>(&'de self) -> T {
         self.assert_ok();
         self.json_parse()
     }
 
     #[track_caller]
     pub fn assert_ok(&self) {
         self.assert_status(StatusCode::OK);
     }
 
     #[track_caller]
     pub fn assert_no_content(&self) {
         self.assert_status(StatusCode::NO_CONTENT);
     }
 
     #[track_caller]
     pub fn assert_error(&self, error_code: ErrorCode) {
         let (status_code, _) = error_code.metadata();
         self.assert_error_status(error_code, StatusCode::from_u16(status_code).unwrap());
     }
 
     #[track_caller]
     pub fn assert_error_status(&self, error_code: ErrorCode, status: StatusCode) {
         self.assert_status(status);
         let err: ErrorDetail = self.json_parse();
         assert_eq!(error_code as u32, err.code);
     }
 
     #[track_caller]
     pub fn query<T: DeserializeOwned>(&self) -> T {
         Query::try_from_uri(&self.uri).unwrap().0
     }
 }