use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::common::{
Address, AuthenticationType, CaptureMethod, Currency, CustomerInfo, ListResponse,
SetupFutureUsage,
};
use crate::core::models::payment::{
PaymentAttemptResponse, PaymentResponse, PaymentStatusHistoryResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Payments {
inner: Arc<Inner>,
}
impl Payments {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn create(&self, params: &PaymentCreateRequest) -> Result<PaymentResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/payments", Some(&body), &[], None)
.await
}
pub async fn create_idempotent(
&self,
params: &PaymentCreateRequest,
idempotency_key: &str,
) -> Result<PaymentResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/payments",
Some(&body),
&[],
Some(idempotency_key),
)
.await
}
pub async fn retrieve(&self, payment_id: &str) -> Result<PaymentResponse> {
let path = format!("/payments/{}", encode_segment(payment_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn retrieve_synced(&self, payment_id: &str) -> Result<PaymentResponse> {
let path = format!("/payments/{}", encode_segment(payment_id));
let query = [
("force_sync", "true".to_string()),
("all_keys_required", "true".to_string()),
];
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn capture(
&self,
payment_id: &str,
params: Option<&PaymentCaptureRequest>,
) -> Result<PaymentResponse> {
let path = format!("/payments/{}/capture", encode_segment(payment_id));
let body: Option<Vec<u8>> = match params {
Some(p) => Some(to_json_vec(p)?),
None => None,
};
self.inner
.request(HttpMethod::Post, &path, body.as_deref(), &[], None)
.await
}
pub async fn cancel(
&self,
payment_id: &str,
params: Option<&PaymentCancelRequest>,
) -> Result<PaymentResponse> {
let path = format!("/payments/{}/cancel", encode_segment(payment_id));
let body: Option<Vec<u8>> = match params {
Some(p) => Some(to_json_vec(p)?),
None => None,
};
self.inner
.request(HttpMethod::Post, &path, body.as_deref(), &[], None)
.await
}
pub async fn list(
&self,
params: Option<&PaymentListParams>,
) -> Result<ListResponse<PaymentResponse>> {
self.list_at("/payments/list", params).await
}
pub async fn update(
&self,
payment_id: &str,
params: &PaymentUpdateRequest,
) -> Result<PaymentResponse> {
params.validate()?;
let path = format!("/payments/{}", encode_segment(payment_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn confirm(
&self,
payment_id: &str,
params: &PaymentConfirmRequest,
) -> Result<PaymentResponse> {
params.validate()?;
let path = format!("/payments/{}/confirm", encode_segment(payment_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn list_attempts(
&self,
payment_id: &str,
) -> Result<ListResponse<PaymentAttemptResponse>> {
let path = format!("/payments/{}/attempts", encode_segment(payment_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn list_status_history(
&self,
payment_id: &str,
) -> Result<PaymentStatusHistoryResponse> {
let path = format!("/payments/{}/status-history", encode_segment(payment_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn session_tokens(&self, params: &Value) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/payments/session-tokens",
Some(&body),
&[],
None,
)
.await
}
pub async fn sync(&self, params: &Value) -> Result<PaymentResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/payments/sync", Some(&body), &[], None)
.await
}
pub async fn cancel_post_capture(
&self,
payment_id: &str,
params: Option<&Value>,
) -> Result<PaymentResponse> {
let path = format!(
"/payments/{}/cancel-post-capture",
encode_segment(payment_id)
);
self.post_value(&path, params).await
}
pub async fn incremental_authorization(
&self,
payment_id: &str,
params: &Value,
) -> Result<PaymentResponse> {
let path = format!(
"/payments/{}/incremental-authorization",
encode_segment(payment_id)
);
self.post_value(&path, Some(params)).await
}
pub async fn extend_authorization(
&self,
payment_id: &str,
params: Option<&Value>,
) -> Result<PaymentResponse> {
let path = format!(
"/payments/{}/extend-authorization",
encode_segment(payment_id)
);
self.post_value(&path, params).await
}
pub async fn complete_authorize(
&self,
payment_id: &str,
params: Option<&Value>,
) -> Result<PaymentResponse> {
let path = format!(
"/payments/{}/complete-authorize",
encode_segment(payment_id)
);
self.post_value(&path, params).await
}
pub async fn calculate_tax(&self, payment_id: &str, params: &Value) -> Result<Value> {
let path = format!("/payments/{}/calculate-tax", encode_segment(payment_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn update_metadata(
&self,
payment_id: &str,
params: &Value,
) -> Result<PaymentResponse> {
let path = format!("/payments/{}/update-metadata", encode_segment(payment_id));
self.post_value(&path, Some(params)).await
}
pub async fn extended_card_info(&self, payment_id: &str) -> Result<Value> {
let path = format!(
"/payments/{}/extended-card-info",
encode_segment(payment_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn list_by_profile(
&self,
params: Option<&PaymentListParams>,
) -> Result<ListResponse<PaymentResponse>> {
self.list_at("/payments/profile/list", params).await
}
pub async fn list_all_shops(
&self,
params: Option<&PaymentListParams>,
) -> Result<ListResponse<PaymentResponse>> {
self.list_at("/payments/list-all-shops", params).await
}
pub async fn list_by_filter(&self, params: &Value) -> Result<ListResponse<PaymentResponse>> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/payments/list", Some(&body), &[], None)
.await
}
pub async fn filters(&self, query: &[(&str, String)]) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/payments/filter", None, query, None)
.await
}
pub async fn aggregate(&self, query: &[(&str, String)]) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/payments/aggregate", None, query, None)
.await
}
pub async fn aggregate_by_profile(&self, query: &[(&str, String)]) -> Result<Value> {
self.inner
.request(
HttpMethod::Get,
"/payments/profile/aggregate",
None,
query,
None,
)
.await
}
pub async fn manual_update(&self, payment_id: &str, params: &Value) -> Result<PaymentResponse> {
let path = format!("/payments/{}/manual-update", encode_segment(payment_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn approve(
&self,
payment_id: &str,
params: Option<&Value>,
) -> Result<PaymentResponse> {
let path = format!("/payments/{}/approve", encode_segment(payment_id));
self.post_value(&path, params).await
}
pub async fn reject(
&self,
payment_id: &str,
params: Option<&Value>,
) -> Result<PaymentResponse> {
let path = format!("/payments/{}/reject", encode_segment(payment_id));
self.post_value(&path, params).await
}
pub async fn three_ds_authentication(&self, payment_id: &str, params: &Value) -> Result<Value> {
let path = format!(
"/payments/{}/3ds/authentication",
encode_segment(payment_id)
);
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
async fn list_at(
&self,
path: &str,
params: Option<&PaymentListParams>,
) -> Result<ListResponse<PaymentResponse>> {
let query = params.map(PaymentListParams::to_query).unwrap_or_default();
let q: Vec<(&str, String)> = query.iter().map(|(k, v)| (*k, v.clone())).collect();
self.inner
.request(HttpMethod::Get, path, None, &q, None)
.await
}
async fn post_value(&self, path: &str, params: Option<&Value>) -> Result<PaymentResponse> {
let body: Option<Vec<u8>> = match params {
Some(p) => Some(to_json_vec(p)?),
None => None,
};
self.inner
.request(HttpMethod::Post, path, body.as_deref(), &[], None)
.await
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PaymentCreateRequest {
pub amount: i64,
pub currency: Currency,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_link: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub confirm: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CaptureMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_to_capture: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<AuthenticationType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerInfo>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<SetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub off_session: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub test_mode: Option<bool>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const PAYMENT_CREATE_REQUEST_NAMED: &[&str] = &[
"amount",
"currency",
"payment_id",
"profile_id",
"payment_link",
"confirm",
"return_url",
"description",
"capture_method",
"amount_to_capture",
"authentication_type",
"customer_id",
"customer",
"email",
"name",
"connector",
"setup_future_usage",
"off_session",
"mandate_id",
"statement_descriptor_name",
"billing",
"shipping",
"metadata",
"test_mode",
];
impl ValidateRequest for PaymentCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if PAYMENT_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on PaymentCreateRequest"
)));
}
}
Ok(())
}
}
impl PaymentCreateRequest {
pub fn new(amount: i64, currency: impl Into<Currency>) -> Self {
Self {
amount,
currency: currency.into(),
..Default::default()
}
}
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
pub fn payment_link(mut self, enabled: bool) -> Self {
self.payment_link = Some(enabled);
self
}
pub fn return_url(mut self, url: impl Into<String>) -> Self {
self.return_url = Some(url.into());
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
pub fn customer_email(mut self, email: impl Into<String>) -> Self {
self.email = Some(email.into());
self
}
pub fn customer_id(mut self, customer_id: impl Into<String>) -> Self {
self.customer_id = Some(customer_id.into());
self
}
pub fn metadata(mut self, metadata: Value) -> Self {
self.metadata = Some(metadata);
self
}
pub fn test_mode(mut self, enabled: bool) -> Self {
self.test_mode = Some(enabled);
self
}
pub fn billing_address(mut self, address: Address) -> Self {
self.billing = serde_json::to_value(address).ok();
self
}
pub fn shipping_address(mut self, address: Address) -> Self {
self.shipping = serde_json::to_value(address).ok();
self
}
}
#[derive(Debug, Clone, Default)]
pub struct PaymentListParams {
pub limit: Option<i64>,
pub offset: Option<i64>,
pub customer_id: Option<String>,
pub created_gte: Option<String>,
pub created_lte: Option<String>,
}
impl PaymentListParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.offset {
q.push(("offset", v.to_string()));
}
if let Some(v) = &self.customer_id {
q.push(("customer_id", v.clone()));
}
if let Some(v) = &self.created_gte {
q.push(("created.gte", v.clone()));
}
if let Some(v) = &self.created_lte {
q.push(("created.lte", v.clone()));
}
q
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PaymentUpdateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<Currency>,
#[serde(skip_serializing_if = "Option::is_none")]
pub order_tax_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_to_capture: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_cost: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub routing: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CaptureMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<AuthenticationType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub confirm: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_suffix: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_data: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<SetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_country_code: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const PAYMENT_UPDATE_REQUEST_NAMED: &[&str] = &[
"amount",
"currency",
"order_tax_amount",
"amount_to_capture",
"shipping_cost",
"routing",
"connector",
"capture_method",
"authentication_type",
"billing",
"confirm",
"customer_id",
"description",
"return_url",
"statement_descriptor_name",
"statement_descriptor_suffix",
"metadata",
"shipping",
"payment_method",
"payment_method_type",
"payment_method_data",
"payment_token",
"setup_future_usage",
"profile_id",
"email",
"name",
"phone",
"phone_country_code",
];
impl ValidateRequest for PaymentUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if PAYMENT_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on PaymentUpdateRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PaymentConfirmRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub client_secret: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_data: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub off_session: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_country_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub browser_info: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CaptureMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const PAYMENT_CONFIRM_REQUEST_NAMED: &[&str] = &[
"client_secret",
"payment_method",
"payment_method_type",
"payment_method_data",
"payment_token",
"return_url",
"billing",
"shipping",
"mandate_id",
"off_session",
"customer_id",
"email",
"name",
"phone",
"phone_country_code",
"browser_info",
"capture_method",
"metadata",
];
impl ValidateRequest for PaymentConfirmRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if PAYMENT_CONFIRM_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on PaymentConfirmRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PaymentCaptureRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_to_capture: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_name: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PaymentCancelRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub cancellation_reason: Option<String>,
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn full_payment_create_request() -> PaymentCreateRequest {
PaymentCreateRequest {
amount: 100,
currency: "EUR".to_string(),
payment_id: Some("pay_1".to_string()),
profile_id: Some("pro_1".to_string()),
payment_link: Some(true),
confirm: Some(true),
return_url: Some("https://example.com/return".to_string()),
description: Some("a description".to_string()),
capture_method: Some(CaptureMethod::Automatic),
amount_to_capture: Some(50),
authentication_type: Some(AuthenticationType::ThreeDs),
customer_id: Some("cus_1".to_string()),
customer: Some(CustomerInfo::default()),
email: Some("ada@example.com".to_string()),
name: Some("Ada".to_string()),
connector: Some(vec!["stripe".to_string()]),
setup_future_usage: Some(SetupFutureUsage::OffSession),
off_session: Some(true),
mandate_id: Some("man_1".to_string()),
statement_descriptor_name: Some("STMT".to_string()),
billing: Some(json!({"address": {"country": "DE"}})),
shipping: Some(json!({"address": {"country": "DE"}})),
metadata: Some(json!({"order_id": "o_1"})),
test_mode: Some(true),
extra: serde_json::Map::new(),
}
}
#[test]
fn payment_create_request_named_fields_are_complete() {
let value = serde_json::to_value(full_payment_create_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
PAYMENT_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"PAYMENT_CREATE_REQUEST_NAMED is missing wire key `{key}` -- \
add it, or PaymentCreateRequest's extra-key collision guard \
will silently stop covering this field"
);
}
}
#[test]
fn validate_rejects_extra_key_colliding_with_named_field() {
let mut req = PaymentCreateRequest::new(100, "EUR");
req.extra.insert("amount".to_string(), json!(999));
let err = req.validate().unwrap_err();
match err {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("amount")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[test]
fn validate_allows_non_colliding_extra_key() {
let mut req = PaymentCreateRequest::new(100, "EUR");
req.extra
.insert("custom_field".to_string(), json!("custom_value"));
req.validate().expect("non-colliding extra key is valid");
let value = serde_json::to_value(&req).unwrap();
assert_eq!(value["custom_field"], json!("custom_value"));
}
fn full_payment_update_request() -> PaymentUpdateRequest {
PaymentUpdateRequest {
amount: Some(100),
currency: Some("EUR".to_string()),
order_tax_amount: Some(10),
amount_to_capture: Some(50),
shipping_cost: Some(5),
routing: Some(json!({"type": "single"})),
connector: Some(vec!["stripe".to_string()]),
capture_method: Some(CaptureMethod::Manual),
authentication_type: Some(AuthenticationType::ThreeDs),
billing: Some(Address::default()),
confirm: Some(true),
customer_id: Some("cus_1".to_string()),
description: Some("desc".to_string()),
return_url: Some("https://example.com/r".to_string()),
statement_descriptor_name: Some("STMT".to_string()),
statement_descriptor_suffix: Some("SFX".to_string()),
metadata: Some(json!({"k": "v"})),
shipping: Some(Address::default()),
payment_method: Some("card".to_string()),
payment_method_type: Some("credit".to_string()),
payment_method_data: Some(json!({"card": {}})),
payment_token: Some("tok_1".to_string()),
setup_future_usage: Some(SetupFutureUsage::OffSession),
profile_id: Some("pro_1".to_string()),
email: Some("ada@example.com".to_string()),
name: Some("Ada".to_string()),
phone: Some("5551234".to_string()),
phone_country_code: Some("+49".to_string()),
extra: serde_json::Map::new(),
}
}
#[test]
fn payment_update_request_named_fields_are_complete() {
let value = serde_json::to_value(full_payment_update_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
PAYMENT_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"PAYMENT_UPDATE_REQUEST_NAMED is missing wire key `{key}` -- \
add it, or PaymentUpdateRequest's extra-key collision guard \
will silently stop covering this field"
);
}
}
#[test]
fn payment_update_validate_rejects_colliding_extra_key() {
let mut req = PaymentUpdateRequest::default();
req.extra.insert("amount".to_string(), json!(1));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
fn full_payment_confirm_request() -> PaymentConfirmRequest {
PaymentConfirmRequest {
client_secret: Some("cs_1".to_string()),
payment_method: Some("card".to_string()),
payment_method_type: Some("credit".to_string()),
payment_method_data: Some(json!({"card": {}})),
payment_token: Some("tok_1".to_string()),
return_url: Some("https://example.com/r".to_string()),
billing: Some(Address::default()),
shipping: Some(Address::default()),
mandate_id: Some("man_1".to_string()),
off_session: Some(true),
customer_id: Some("cus_1".to_string()),
email: Some("ada@example.com".to_string()),
name: Some("Ada".to_string()),
phone: Some("5551234".to_string()),
phone_country_code: Some("+49".to_string()),
browser_info: Some(json!({"user_agent": "ua"})),
capture_method: Some(CaptureMethod::Automatic),
metadata: Some(json!({"k": "v"})),
extra: serde_json::Map::new(),
}
}
#[test]
fn payment_confirm_request_named_fields_are_complete() {
let value = serde_json::to_value(full_payment_confirm_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
PAYMENT_CONFIRM_REQUEST_NAMED.contains(&key.as_str()),
"PAYMENT_CONFIRM_REQUEST_NAMED is missing wire key `{key}` -- \
add it, or PaymentConfirmRequest's extra-key collision guard \
will silently stop covering this field"
);
}
}
#[test]
fn payment_confirm_validate_rejects_colliding_extra_key() {
let mut req = PaymentConfirmRequest::default();
req.extra.insert("payment_token".to_string(), json!("t"));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
use crate::http::mock::{Step, client_with};
#[tokio::test]
async fn update_posts_to_the_payment_path() {
let (client, mock) = client_with(vec![Step::ok(PAYMENT_JSON)]);
let req = PaymentUpdateRequest {
amount: Some(700),
..Default::default()
};
client.payments().update("pay_1", &req).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/payments/pay_1");
assert_eq!(seen[0].body_json()["amount"], 700);
}
#[tokio::test]
async fn confirm_posts_to_the_confirm_path() {
let (client, mock) = client_with(vec![Step::ok(PAYMENT_JSON)]);
let req = PaymentConfirmRequest {
payment_token: Some("tok_1".to_string()),
..Default::default()
};
client.payments().confirm("pay_1", &req).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/payments/pay_1/confirm");
assert_eq!(seen[0].body_json()["payment_token"], "tok_1");
}
#[tokio::test]
async fn list_attempts_gets_the_attempts_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"size":1,"data":[{"attempt_id":"att_1","status":"charged"}]}"#,
)]);
let out = client.payments().list_attempts("pay_1").await.unwrap();
assert_eq!(out.data[0].attempt_id, "att_1");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/payments/pay_1/attempts");
}
#[tokio::test]
async fn list_status_history_gets_the_status_history_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"payment_id":"pay_1","complete":true,"count":1,
"events":[{"entity_type":"payment","timestamp":"2026-08-01T10:00:00Z",
"status":"succeeded","is_creation":false,"derived":false}]}"#,
)]);
let history = client
.payments()
.list_status_history("pay_1")
.await
.unwrap();
assert!(history.complete);
assert_eq!(history.events[0].entity_type, "payment");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/payments/pay_1/status-history"
);
}
#[tokio::test]
async fn advanced_operations_hit_their_documented_paths() {
let steps = vec![
Step::ok(r#"{"token":"st_1"}"#),
Step::ok(PAYMENT_JSON),
Step::ok(PAYMENT_JSON),
Step::ok(PAYMENT_JSON),
Step::ok(PAYMENT_JSON),
Step::ok(PAYMENT_JSON),
Step::ok(r#"{"net":100}"#),
Step::ok(PAYMENT_JSON),
Step::ok(r#"{"card_number":"4242"}"#),
Step::ok(r#"{"trans_status":"Y"}"#),
];
let (client, mock) = client_with(steps);
let p = client.payments();
let body = json!({"k": "v"});
p.session_tokens(&body).await.unwrap();
p.sync(&body).await.unwrap();
p.cancel_post_capture("pay_1", None).await.unwrap();
p.incremental_authorization("pay_1", &body).await.unwrap();
p.extend_authorization("pay_1", None).await.unwrap();
p.complete_authorize("pay_1", Some(&body)).await.unwrap();
p.calculate_tax("pay_1", &body).await.unwrap();
p.update_metadata("pay_1", &body).await.unwrap();
p.extended_card_info("pay_1").await.unwrap();
p.three_ds_authentication("pay_1", &body).await.unwrap();
let expected = [
("POST", "https://api.test/payments/session-tokens"),
("POST", "https://api.test/payments/sync"),
(
"POST",
"https://api.test/payments/pay_1/cancel-post-capture",
),
(
"POST",
"https://api.test/payments/pay_1/incremental-authorization",
),
(
"POST",
"https://api.test/payments/pay_1/extend-authorization",
),
("POST", "https://api.test/payments/pay_1/complete-authorize"),
("POST", "https://api.test/payments/pay_1/calculate-tax"),
("POST", "https://api.test/payments/pay_1/update-metadata"),
("GET", "https://api.test/payments/pay_1/extended-card-info"),
("POST", "https://api.test/payments/pay_1/3ds/authentication"),
];
let seen = mock.seen.lock().unwrap();
assert_eq!(seen.len(), expected.len());
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(seen[i].method, *method, "wrong verb at call {i}");
assert_eq!(seen[i].url, *url, "wrong URL at call {i}");
}
}
#[tokio::test]
async fn list_by_profile_gets_the_profile_list_path_with_query() {
let (client, mock) = client_with(vec![Step::ok(LIST_JSON)]);
let params = PaymentListParams {
limit: Some(25),
customer_id: Some("cus_1".to_string()),
..Default::default()
};
client
.payments()
.list_by_profile(Some(¶ms))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/payments/profile/list?limit=25&customer_id=cus_1"
);
}
#[tokio::test]
async fn list_all_shops_gets_the_all_shops_path() {
let (client, mock) = client_with(vec![Step::ok(LIST_JSON)]);
client.payments().list_all_shops(None).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/payments/list-all-shops");
}
#[tokio::test]
async fn list_by_filter_posts_the_filter_body() {
let (client, mock) = client_with(vec![Step::ok(LIST_JSON)]);
client
.payments()
.list_by_filter(&json!({"status": ["succeeded"]}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/payments/list");
assert_eq!(seen[0].body_json()["status"][0], "succeeded");
}
#[tokio::test]
async fn filters_gets_the_filter_path_with_query() {
let (client, mock) = client_with(vec![Step::ok(r#"{"connector":["stripe"]}"#)]);
client
.payments()
.filters(&[("profile_id", "pro_1".to_string())])
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/payments/filter?profile_id=pro_1"
);
}
#[tokio::test]
async fn aggregate_gets_the_aggregate_path_with_query() {
let (client, mock) = client_with(vec![Step::ok(r#"{"count":3}"#)]);
client
.payments()
.aggregate(&[("time_range", "7d".to_string())])
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/payments/aggregate?time_range=7d"
);
}
#[tokio::test]
async fn aggregate_by_profile_gets_the_profile_aggregate_path() {
let (client, mock) = client_with(vec![Step::ok(r#"{"count":3}"#)]);
client.payments().aggregate_by_profile(&[]).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/payments/profile/aggregate");
}
#[tokio::test]
async fn manual_update_puts_to_the_manual_update_path() {
let (client, mock) = client_with(vec![Step::ok(PAYMENT_JSON)]);
client
.payments()
.manual_update("pay/1", &json!({"status": "charged"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/payments/pay%2F1/manual-update"
);
assert_eq!(seen[0].body_json()["status"], "charged");
}
#[tokio::test]
async fn approve_posts_to_the_approve_path_with_its_body() {
let (client, mock) = client_with(vec![Step::ok(PAYMENT_JSON)]);
client
.payments()
.approve("pay_1", Some(&json!({"reason": "manual review"})))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/payments/pay_1/approve");
assert_eq!(seen[0].body_json()["reason"], "manual review");
}
#[tokio::test]
async fn reject_posts_to_the_reject_path_with_its_body() {
let (client, mock) = client_with(vec![Step::ok(PAYMENT_JSON)]);
client
.payments()
.reject("pay_1", Some(&json!({"reason": "fraud"})))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/payments/pay_1/reject");
assert_eq!(seen[0].body_json()["reason"], "fraud");
}
const LIST_JSON: &str = r#"{"size":0,"data":[]}"#;
const PAYMENT_JSON: &str = r#"{
"payment_id": "pay_1", "merchant_id": "mer_1", "status": "succeeded",
"amount": 500, "currency": "EUR"
}"#;
}