use std::future::Future;
use std::pin::Pin;
use std::time::Duration;
use url::Url;
use crate::error::Result;
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct TransportOptions {
pub max_response_bytes: usize,
pub timeout: Option<Duration>,
}
impl TransportOptions {
pub fn new(max_response_bytes: usize) -> Self {
Self {
max_response_bytes,
timeout: None,
}
}
pub fn with_timeout(mut self, timeout: Option<Duration>) -> Self {
self.timeout = timeout;
self
}
}
pub trait Transport: Send + Sync {
fn get<'a>(&'a self, url: &'a Url, options: TransportOptions)
-> BoxFuture<'a, Result<Vec<u8>>>;
fn post_form<'a>(
&'a self,
url: &'a Url,
form: &'a [(&'a str, &'a str)],
options: TransportOptions,
) -> BoxFuture<'a, Result<Vec<u8>>>;
fn sleep(&self, duration: Duration) -> BoxFuture<'_, ()>;
}
#[cfg(any(feature = "reqwest-rustls", feature = "reqwest-native-tls"))]
pub(crate) use reqwest_impl::ReqwestTransport;
#[cfg(any(feature = "reqwest-rustls", feature = "reqwest-native-tls"))]
mod reqwest_impl {
use std::time::Duration;
use url::Url;
use super::{BoxFuture, Transport, TransportOptions};
use crate::error::{Error, Result, TransportErrorKind};
#[derive(Clone)]
pub struct ReqwestTransport {
client: reqwest::Client,
}
impl ReqwestTransport {
pub fn new(timeout: Duration, connect_timeout: Option<Duration>) -> Result<Self> {
let mut builder = reqwest::Client::builder()
.timeout(timeout)
.redirect(reqwest::redirect::Policy::none())
.user_agent(concat!("epay-sdk-rust/", env!("CARGO_PKG_VERSION")));
if let Some(connect_timeout) = connect_timeout {
builder = builder.connect_timeout(connect_timeout);
}
#[cfg(feature = "reqwest-rustls")]
let builder = builder.use_rustls_tls();
#[cfg(all(feature = "reqwest-native-tls", not(feature = "reqwest-rustls")))]
let builder = builder.use_native_tls();
let client = builder.build().map_err(map_reqwest_error)?;
Ok(Self { client })
}
pub fn from_client(client: reqwest::Client) -> Self {
Self { client }
}
async fn send(
request: reqwest::RequestBuilder,
options: TransportOptions,
) -> Result<Vec<u8>> {
let request = match options.timeout {
Some(timeout) => request.timeout(timeout),
None => request,
};
let response = request.send().await.map_err(map_reqwest_error)?;
Self::read_response(response, options.max_response_bytes).await
}
async fn read_response(
mut response: reqwest::Response,
max_response_bytes: usize,
) -> Result<Vec<u8>> {
let status = response.status();
if response
.content_length()
.is_some_and(|length| length > max_response_bytes as u64)
{
return Err(Error::ResponseTooLarge {
limit: max_response_bytes,
});
}
let mut body = Vec::with_capacity(
response
.content_length()
.unwrap_or(0)
.min(max_response_bytes as u64) as usize,
);
while let Some(chunk) = response.chunk().await.map_err(map_reqwest_error)? {
if body.len().saturating_add(chunk.len()) > max_response_bytes {
return Err(Error::ResponseTooLarge {
limit: max_response_bytes,
});
}
body.extend_from_slice(&chunk);
}
if !status.is_success() {
return Err(Error::http(status.as_u16(), &body));
}
Ok(body)
}
}
impl Transport for ReqwestTransport {
fn get<'a>(
&'a self,
url: &'a Url,
options: TransportOptions,
) -> BoxFuture<'a, Result<Vec<u8>>> {
Box::pin(Self::send(self.client.get(url.clone()), options))
}
fn post_form<'a>(
&'a self,
url: &'a Url,
form: &'a [(&'a str, &'a str)],
options: TransportOptions,
) -> BoxFuture<'a, Result<Vec<u8>>> {
Box::pin(Self::send(
self.client.post(url.clone()).form(form),
options,
))
}
fn sleep(&self, duration: Duration) -> BoxFuture<'_, ()> {
Box::pin(tokio::time::sleep(duration))
}
}
fn map_reqwest_error(error: reqwest::Error) -> Error {
let (kind, message) = if error.is_timeout() {
(TransportErrorKind::Timeout, "request timed out")
} else if error.is_connect() {
(TransportErrorKind::Connect, "connection failed")
} else if error.is_redirect() {
(TransportErrorKind::Redirect, "redirect rejected")
} else if error.is_body() || error.is_decode() {
(TransportErrorKind::Body, "response body read failed")
} else if error.is_builder() || error.is_request() {
(
TransportErrorKind::Request,
"request could not be built or sent",
)
} else {
(TransportErrorKind::Other, "request failed")
};
Error::transport(kind, message)
}
}
#[cfg(any(test, feature = "test-util"))]
pub use mock::{MockTransport, RecordedRequest};
#[cfg(any(test, feature = "test-util"))]
mod mock {
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use url::Url;
use super::{BoxFuture, Transport, TransportOptions};
use crate::error::{Error, Result, TransportErrorKind};
use crate::params::Params;
#[derive(Clone, Default)]
pub struct MockTransport {
inner: Arc<MockInner>,
}
#[derive(Default)]
struct MockInner {
responses: Mutex<VecDeque<Result<Vec<u8>>>>,
requests: Mutex<Vec<RecordedRequest>>,
sleeps: Mutex<Vec<Duration>>,
}
#[derive(Clone, Debug)]
pub struct RecordedRequest {
pub method: &'static str,
pub url: String,
pub query: Params,
pub form: Params,
pub options: TransportOptions,
}
impl std::fmt::Debug for MockTransport {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let remaining = self
.inner
.responses
.lock()
.map(|queue| queue.len())
.unwrap_or(0);
f.debug_struct("MockTransport")
.field("queued_responses", &remaining)
.finish()
}
}
impl MockTransport {
pub fn new() -> Self {
Self::default()
}
pub fn push_json(self, body: impl Into<String>) -> Self {
self.push_bytes(body.into().into_bytes())
}
pub fn push_bytes(self, body: Vec<u8>) -> Self {
self.inner
.responses
.lock()
.expect("mock transport mutex")
.push_back(Ok(body));
self
}
pub fn push_err(self, err: Error) -> Self {
self.inner
.responses
.lock()
.expect("mock transport mutex")
.push_back(Err(err));
self
}
pub fn recorded(&self) -> Vec<RecordedRequest> {
self.inner
.requests
.lock()
.expect("mock transport mutex")
.clone()
}
pub fn recorded_sleeps(&self) -> Vec<Duration> {
self.inner
.sleeps
.lock()
.expect("mock transport mutex")
.clone()
}
fn next(
&self,
method: &'static str,
url: &Url,
form: Params,
options: TransportOptions,
) -> Result<Vec<u8>> {
let query: Params = url.query_pairs().collect();
let mut bare = url.clone();
bare.set_query(None);
self.inner
.requests
.lock()
.expect("mock transport mutex")
.push(RecordedRequest {
method,
url: bare.to_string(),
query,
form,
options,
});
let response = self
.inner
.responses
.lock()
.expect("mock transport mutex")
.pop_front()
.unwrap_or_else(|| {
Err(Error::transport(
TransportErrorKind::Other,
"mock transport has no scripted response",
))
})?;
if response.len() > options.max_response_bytes {
return Err(Error::ResponseTooLarge {
limit: options.max_response_bytes,
});
}
Ok(response)
}
}
impl Transport for MockTransport {
fn get<'a>(
&'a self,
url: &'a Url,
options: TransportOptions,
) -> BoxFuture<'a, Result<Vec<u8>>> {
Box::pin(async move { self.next("GET", url, Params::new(), options) })
}
fn post_form<'a>(
&'a self,
url: &'a Url,
form: &'a [(&'a str, &'a str)],
options: TransportOptions,
) -> BoxFuture<'a, Result<Vec<u8>>> {
let form: Params = form.iter().copied().collect();
Box::pin(async move { self.next("POST", url, form, options) })
}
fn sleep(&self, duration: Duration) -> BoxFuture<'_, ()> {
self.inner
.sleeps
.lock()
.expect("mock transport mutex")
.push(duration);
Box::pin(async {})
}
}
}