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::checkout_method::{
CheckoutAccountVisibilityResponse, CheckoutEntriesResponse, CheckoutEntry,
CheckoutMethodsAvailabilityResponse, CheckoutMethodsChildrenResponse,
CheckoutMethodsResetResponse, CheckoutMethodsResponse, CheckoutPaymentMethodOptionsResponse,
CheckoutRedirectRulesTestResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct CheckoutMethods {
inner: Arc<Inner>,
}
impl CheckoutMethods {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn retrieve(
&self,
merchant_id: &str,
profile_id: &str,
environment: CheckoutEnvironment,
) -> Result<CheckoutMethodsResponse> {
self.inner
.request(
HttpMethod::Get,
&methods_path(profile_id, environment),
None,
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn update(
&self,
merchant_id: &str,
profile_id: &str,
params: &CheckoutMethodsUpdateRequest,
environment: CheckoutEnvironment,
) -> Result<CheckoutMethodsResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Put,
&methods_path(profile_id, environment),
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn reset(
&self,
merchant_id: &str,
profile_id: &str,
environment: CheckoutEnvironment,
) -> Result<CheckoutMethodsResetResponse> {
self.inner
.request_body_keyed_with_query(
HttpMethod::Delete,
&methods_path(profile_id, environment),
None,
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn availability(
&self,
merchant_id: &str,
profile_id: &str,
params: &CheckoutMethodsAvailabilityParams,
) -> Result<CheckoutMethodsAvailabilityResponse> {
let environment = if params.test_mode {
CheckoutEnvironment::Test
} else {
CheckoutEnvironment::Live
};
let path = format!("{}/availability", methods_path(profile_id, environment));
let query = vec![
("merchant_id", merchant_id.to_string()),
("country", params.country.clone()),
("amount", params.amount.to_string()),
("currency", params.currency.clone()),
];
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn children(
&self,
merchant_id: &str,
profile_id: &str,
params: &CheckoutMethodsChildrenParams,
) -> Result<CheckoutMethodsChildrenResponse> {
let path = format!("{}/children", methods_path(profile_id, params.environment));
let mut query = merchant_query(merchant_id);
if let Some(country) = ¶ms.country {
query.push(("country", country.clone()));
}
if let Some(currency) = ¶ms.currency {
query.push(("currency", currency.clone()));
}
if let Some(amount) = params.amount {
query.push(("amount", amount.to_string()));
}
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn set_account_visibility(
&self,
merchant_id: &str,
profile_id: &str,
merchant_connector_id: &str,
params: &CheckoutAccountVisibilityRequest,
) -> Result<CheckoutAccountVisibilityResponse> {
let path = format!(
"/checkout-methods/{}/accounts/{}/visibility",
encode_segment(profile_id),
encode_segment(merchant_connector_id)
);
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Put,
&path,
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn preview(
&self,
merchant_id: &str,
profile_id: &str,
environment: CheckoutEnvironment,
) -> Result<CheckoutMethodsResponse> {
let path = format!("{}/preview", methods_path(profile_id, environment));
self.inner
.request(
HttpMethod::Get,
&path,
None,
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn payment_method_options(
&self,
merchant_id: &str,
profile_id: &str,
environment: CheckoutEnvironment,
) -> Result<CheckoutPaymentMethodOptionsResponse> {
let path = format!(
"{}/payment-method-options",
methods_path(profile_id, environment)
);
self.inner
.request(
HttpMethod::Get,
&path,
None,
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn test_redirect_rules(
&self,
merchant_id: &str,
profile_id: &str,
params: &CheckoutRedirectRulesTestRequest,
environment: CheckoutEnvironment,
) -> Result<CheckoutRedirectRulesTestResponse> {
params.validate()?;
let path = format!(
"{}/redirect-rules/test",
methods_path(profile_id, environment)
);
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
&path,
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn entries(
&self,
merchant_id: &str,
profile_id: &str,
environment: CheckoutEnvironment,
) -> Result<CheckoutEntriesResponse> {
self.inner
.request(
HttpMethod::Get,
&entries_path(profile_id, environment),
None,
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn update_entries(
&self,
merchant_id: &str,
profile_id: &str,
params: &CheckoutEntriesUpdateRequest,
environment: CheckoutEnvironment,
) -> Result<CheckoutEntriesResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Put,
&entries_path(profile_id, environment),
Some(&body),
&merchant_query(merchant_id),
None,
)
.await
}
pub async fn clear_entries(
&self,
merchant_id: &str,
profile_id: &str,
environment: CheckoutEnvironment,
) -> Result<CheckoutEntriesResponse> {
self.inner
.request_body_keyed_with_query(
HttpMethod::Delete,
&entries_path(profile_id, environment),
None,
&merchant_query(merchant_id),
None,
)
.await
}
}
fn entries_path(profile_id: &str, environment: CheckoutEnvironment) -> String {
format!("{}/entries", methods_path(profile_id, environment))
}
fn methods_path(profile_id: &str, environment: CheckoutEnvironment) -> String {
let shop = format!("/checkout-methods/{}", encode_segment(profile_id));
match environment {
CheckoutEnvironment::Live => shop,
CheckoutEnvironment::Test => format!("{shop}/test"),
}
}
fn merchant_query(merchant_id: &str) -> Vec<(&'static str, String)> {
vec![("merchant_id", merchant_id.to_string())]
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CheckoutEnvironment {
#[default]
Live,
Test,
}
#[derive(Debug, Clone, Serialize)]
pub struct CheckoutMethodsUpdateRequest {
pub layout: Value,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl CheckoutMethodsUpdateRequest {
pub fn new(layout: Value) -> Self {
Self {
layout,
extra: serde_json::Map::new(),
}
}
}
const CHECKOUT_METHODS_UPDATE_REQUEST_NAMED: &[&str] = &["layout"];
impl ValidateRequest for CheckoutMethodsUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CHECKOUT_METHODS_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on CheckoutMethodsUpdateRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default)]
pub struct CheckoutMethodsAvailabilityParams {
pub country: String,
pub amount: i64,
pub currency: String,
pub test_mode: bool,
}
impl CheckoutMethodsAvailabilityParams {
pub fn new(country: impl Into<String>, amount: i64, currency: impl Into<String>) -> Self {
Self {
country: country.into(),
amount,
currency: currency.into(),
test_mode: false,
}
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = test_mode;
self
}
}
#[derive(Debug, Clone, Default)]
pub struct CheckoutMethodsChildrenParams {
pub environment: CheckoutEnvironment,
pub country: Option<String>,
pub currency: Option<String>,
pub amount: Option<i64>,
}
impl CheckoutMethodsChildrenParams {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn environment(mut self, environment: CheckoutEnvironment) -> Self {
self.environment = environment;
self
}
#[must_use]
pub fn country(mut self, country: impl Into<String>) -> Self {
self.country = Some(country.into());
self
}
#[must_use]
pub fn order(mut self, amount: i64, currency: impl Into<String>) -> Self {
self.amount = Some(amount);
self.currency = Some(currency.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CheckoutEntriesUpdateRequest {
pub entries: Vec<CheckoutEntry>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl CheckoutEntriesUpdateRequest {
pub fn new(entries: Vec<CheckoutEntry>) -> Self {
Self {
entries,
extra: serde_json::Map::new(),
}
}
}
const CHECKOUT_ENTRIES_UPDATE_REQUEST_NAMED: &[&str] = &["entries"];
const CHECKOUT_ENTRY_NAMED: &[&str] = &["key", "label", "kind", "methods", "theme", "other_entry"];
const CHECKOUT_ENTRY_METHOD_NAMED: &[&str] =
&["kind", "group_id", "connector", "method", "capability"];
fn reject_collisions(
extra: &serde_json::Map<String, Value>,
named: &[&str],
type_name: &str,
) -> Result<()> {
for key in extra.keys() {
if named.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on {type_name}"
)));
}
}
Ok(())
}
impl ValidateRequest for CheckoutEntriesUpdateRequest {
fn validate(&self) -> Result<()> {
reject_collisions(
&self.extra,
CHECKOUT_ENTRIES_UPDATE_REQUEST_NAMED,
"CheckoutEntriesUpdateRequest",
)?;
for entry in &self.entries {
reject_collisions(&entry.extra, CHECKOUT_ENTRY_NAMED, "CheckoutEntry")?;
for method in &entry.methods {
reject_collisions(
&method.extra,
CHECKOUT_ENTRY_METHOD_NAMED,
"CheckoutEntryMethod",
)?;
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CheckoutRedirectRulesTestRequest {
pub rules: Value,
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
pub currency: String,
pub amount: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<std::collections::BTreeMap<String, String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cap_states: Option<serde_json::Map<String, Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub health_states: Option<serde_json::Map<String, Value>>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl CheckoutRedirectRulesTestRequest {
pub fn new(rules: Value, amount: i64, currency: impl Into<String>) -> Self {
Self {
rules,
amount,
currency: currency.into(),
..Default::default()
}
}
#[must_use]
pub fn country(mut self, country: impl Into<String>) -> Self {
self.country = Some(country.into());
self
}
#[must_use]
pub fn device(mut self, device: impl Into<String>) -> Self {
self.device = Some(device.into());
self
}
#[must_use]
pub fn metadata(mut self, metadata: std::collections::BTreeMap<String, String>) -> Self {
self.metadata = Some(metadata);
self
}
#[must_use]
pub fn cap_states(mut self, cap_states: serde_json::Map<String, Value>) -> Self {
self.cap_states = Some(cap_states);
self
}
#[must_use]
pub fn health_states(mut self, health_states: serde_json::Map<String, Value>) -> Self {
self.health_states = Some(health_states);
self
}
}
const CHECKOUT_REDIRECT_RULES_TEST_REQUEST_NAMED: &[&str] = &[
"rules",
"country",
"currency",
"amount",
"device",
"metadata",
"cap_states",
"health_states",
];
impl ValidateRequest for CheckoutRedirectRulesTestRequest {
fn validate(&self) -> Result<()> {
reject_collisions(
&self.extra,
CHECKOUT_REDIRECT_RULES_TEST_REQUEST_NAMED,
"CheckoutRedirectRulesTestRequest",
)
}
}
#[derive(Debug, Clone, Serialize)]
pub struct CheckoutAccountVisibilityRequest {
pub hidden: bool,
pub environments: Vec<CheckoutEnvironment>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
}
impl CheckoutAccountVisibilityRequest {
pub fn new(hidden: bool, environments: Vec<CheckoutEnvironment>) -> Self {
Self {
hidden,
environments,
reason: None,
}
}
#[must_use]
pub fn reason(mut self, reason: impl Into<String>) -> Self {
self.reason = Some(reason.into());
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::models::checkout_method::CheckoutEntryMethod;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const METHODS_JSON: &str = r#"{
"profile_id": "pro_1",
"source": "stored",
"layout": {"express": [], "normal": [{"kind": "card"}], "alternative": []},
"available": [{
"kind": "card",
"default_label": "Card",
"default_category": "normal",
"supports_native_element": true,
"supports_open_target": false,
"account_enabled": true,
"accounts": [{"merchant_connector_id": "mca_1"}]
}],
"modified_at": "2026-01-01T00:00:00Z",
"test_mode": false,
"hidden_accounts": ["mca_2"],
"surprise_field": 1
}"#;
#[tokio::test]
async fn retrieve_gets_the_live_layout_with_the_merchant_scope() {
let (client, mock) = client_with(vec![Step::ok(METHODS_JSON)]);
let out = client
.checkout_methods()
.retrieve("mer_1", "pro/1", CheckoutEnvironment::Live)
.await
.unwrap();
assert_eq!(out.profile_id, "pro_1");
assert_eq!(out.source, "stored");
assert_eq!(out.layout["normal"][0]["kind"], "card");
assert_eq!(out.available[0].default_category, "normal");
assert!(out.available[0].supports_native_element);
assert_eq!(
out.available[0].extra["accounts"][0]["merchant_connector_id"],
"mca_1"
);
assert_eq!(out.hidden_accounts, ["mca_2"]);
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro%2F1?merchant_id=mer_1"
);
}
#[tokio::test]
async fn update_puts_the_test_layout() {
let (client, mock) = client_with(vec![Step::ok(METHODS_JSON)]);
let layout = json!({"express": [], "normal": [{"kind": "card"}], "alternative": []});
client
.checkout_methods()
.update(
"mer_1",
"pro_1",
&CheckoutMethodsUpdateRequest::new(layout.clone()),
CheckoutEnvironment::Test,
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/test?merchant_id=mer_1"
);
assert_eq!(seen[0].body_json(), json!({ "layout": layout }));
}
#[tokio::test]
async fn reset_deletes_the_live_layout() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"profile_id":"pro_1","deleted":true,"surprise_field":"x"}"#,
)]);
let out = client
.checkout_methods()
.reset("mer_1", "pro_1", CheckoutEnvironment::Live)
.await
.unwrap();
assert!(out.deleted);
assert_eq!(out.extra["surprise_field"], "x");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1?merchant_id=mer_1"
);
assert!(seen[0].body.is_none());
}
const AVAILABILITY_JSON: &str = r#"{
"profile_id": "pro_1",
"country": "DE",
"amount": 1999,
"currency": "EUR",
"country_defaults_enabled": true,
"items": [{"kind": "method", "connector": "mollie", "method": "ideal", "hidden_by": ["country_default"]}],
"smart_blocks": [],
"surprise_field": true
}"#;
#[tokio::test]
async fn availability_asks_live_with_the_buyer_query() {
let (client, mock) = client_with(vec![Step::ok(AVAILABILITY_JSON)]);
let out = client
.checkout_methods()
.availability(
"mer_1",
"pro_1",
&CheckoutMethodsAvailabilityParams::new("DE", 1999, "EUR"),
)
.await
.unwrap();
assert_eq!(out.amount, 1999);
assert_eq!(out.items[0].hidden_by, ["country_default"]);
assert_eq!(out.items[0].method.as_deref(), Some("ideal"));
assert_eq!(out.extra["surprise_field"], true);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/availability?merchant_id=mer_1&country=DE&amount=1999¤cy=EUR"
);
}
#[tokio::test]
async fn availability_in_test_mode_asks_the_test_path() {
let (client, mock) = client_with(vec![Step::ok(AVAILABILITY_JSON)]);
client
.checkout_methods()
.availability(
"mer_1",
"pro_1",
&CheckoutMethodsAvailabilityParams::new("DE", 1999, "EUR").test_mode(true),
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/test/availability?merchant_id=mer_1&country=DE&amount=1999¤cy=EUR"
);
}
const CHILDREN_JSON: &str = r#"{
"profile_id": "pro_1",
"test_mode": false,
"items": [{
"kind": "card",
"status": "confirmed",
"stale": false,
"complete": true,
"children": [{"id": "card_network:visa", "kind": "card_network"}],
"declarable": []
}],
"surprise_field": 2
}"#;
#[tokio::test]
async fn children_without_an_order_sends_only_the_merchant_scope() {
let (client, mock) = client_with(vec![Step::ok(CHILDREN_JSON)]);
let out = client
.checkout_methods()
.children("mer_1", "pro_1", &CheckoutMethodsChildrenParams::new())
.await
.unwrap();
assert_eq!(out.items[0].status, "confirmed");
assert_eq!(out.items[0].children[0].id, "card_network:visa");
assert!(out.items[0].complete);
assert_eq!(out.extra["surprise_field"], 2);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/children?merchant_id=mer_1"
);
}
#[tokio::test]
async fn children_for_test_with_an_order_asks_the_test_path() {
let (client, mock) = client_with(vec![Step::ok(CHILDREN_JSON)]);
let params = CheckoutMethodsChildrenParams::new()
.environment(CheckoutEnvironment::Test)
.country("NL")
.order(500, "EUR");
client
.checkout_methods()
.children("mer_1", "pro_1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/test/children?merchant_id=mer_1&country=NL¤cy=EUR&amount=500"
);
}
#[tokio::test]
async fn set_account_visibility_puts_the_account_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"merchant_connector_id":"mca_1","hidden_live":true,"hidden_test":false,"surprise_field":0}"#,
)]);
let params = CheckoutAccountVisibilityRequest::new(true, vec![CheckoutEnvironment::Live])
.reason("paused");
let out = client
.checkout_methods()
.set_account_visibility("mer_1", "pro_1", "mca/1", ¶ms)
.await
.unwrap();
assert!(out.hidden_live);
assert!(!out.hidden_test);
assert_eq!(out.extra["surprise_field"], 0);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/accounts/mca%2F1/visibility?merchant_id=mer_1"
);
assert_eq!(
seen[0].body_json(),
json!({"hidden": true, "environments": ["live"], "reason": "paused"})
);
}
#[test]
fn checkout_methods_update_request_named_fields_are_complete() {
let req = CheckoutMethodsUpdateRequest::new(json!({"normal": []}));
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
CHECKOUT_METHODS_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"CHECKOUT_METHODS_UPDATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn update_validate_rejects_colliding_extra_key() {
let mut req = CheckoutMethodsUpdateRequest::new(json!({}));
req.extra.insert("layout".to_string(), json!({}));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("layout")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[tokio::test]
async fn preview_gets_the_test_preview_path() {
let (client, mock) = client_with(vec![Step::ok(METHODS_JSON)]);
let out = client
.checkout_methods()
.preview("mer_1", "pro_1", CheckoutEnvironment::Test)
.await
.unwrap();
assert_eq!(out.profile_id, "pro_1");
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/test/preview?merchant_id=mer_1"
);
}
#[tokio::test]
async fn payment_method_options_gets_the_live_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"profile_id":"pro_1","test_mode":false,"options":[
{"payment_method":"card","payment_method_types":["credit","debit"],
"option_surprise":true}],"surprise_field":1}"#,
)]);
let out = client
.checkout_methods()
.payment_method_options("mer_1", "pro/1", CheckoutEnvironment::Live)
.await
.unwrap();
assert!(!out.test_mode);
assert_eq!(out.options[0].payment_method, "card");
assert_eq!(out.options[0].payment_method_types, ["credit", "debit"]);
assert_eq!(out.options[0].extra["option_surprise"], true);
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro%2F1/payment-method-options?merchant_id=mer_1"
);
}
#[tokio::test]
async fn test_redirect_rules_posts_the_rules_and_the_buyer() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"decision":{"kind":"redirect"},"rules":[{"matched":true}],
"offered":[],"accounts":[],"surprise_field":1}"#,
)]);
let mut metadata = std::collections::BTreeMap::new();
metadata.insert("channel".to_string(), "web".to_string());
let params = CheckoutRedirectRulesTestRequest::new(json!({"rules": []}), 1999, "EUR")
.country("DE")
.device("mobile")
.metadata(metadata);
let out = client
.checkout_methods()
.test_redirect_rules("mer_1", "pro_1", ¶ms, CheckoutEnvironment::Test)
.await
.unwrap();
assert_eq!(out.decision.as_ref().unwrap()["kind"], "redirect");
assert_eq!(out.rules[0]["matched"], true);
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/test/redirect-rules/test?merchant_id=mer_1"
);
assert_eq!(
seen[0].body_json(),
json!({
"rules": {"rules": []},
"country": "DE",
"currency": "EUR",
"amount": 1999,
"device": "mobile",
"metadata": {"channel": "web"}
})
);
assert!(!seen[0].had_idempotency_key());
}
const ENTRIES_JSON: &str = r#"{
"profile_id": "pro_1",
"test_mode": false,
"entries": [{
"key": "crypto", "label": "Pay with crypto", "kind": "methods",
"methods": [{"kind": "method", "connector": "cryptomus", "method": "crypto"}],
"theme": "dark", "entry_surprise": 1
}],
"modified_at": "2026-11-01T00:00:00Z",
"surprise_field": 1
}"#;
#[tokio::test]
async fn entries_gets_the_live_entries_path() {
let (client, mock) = client_with(vec![Step::ok(ENTRIES_JSON)]);
let out = client
.checkout_methods()
.entries("mer_1", "pro_1", CheckoutEnvironment::Live)
.await
.unwrap();
assert_eq!(out.entries[0].key, "crypto");
assert_eq!(
out.entries[0].methods[0].connector.as_deref(),
Some("cryptomus")
);
assert_eq!(out.entries[0].extra["entry_surprise"], 1);
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/entries?merchant_id=mer_1"
);
}
#[tokio::test]
async fn update_entries_puts_the_test_entries_and_round_trips_unknown_fields() {
let (client, mock) = client_with(vec![Step::ok(ENTRIES_JSON), Step::ok(ENTRIES_JSON)]);
let read = client
.checkout_methods()
.entries("mer_1", "pro_1", CheckoutEnvironment::Live)
.await
.unwrap();
let mut entries = read.entries;
entries.push(
CheckoutEntry::new("card", "Card form")
.kind("card")
.other_entry("crypto"),
);
let params = CheckoutEntriesUpdateRequest::new(entries);
client
.checkout_methods()
.update_entries("mer_1", "pro_1", ¶ms, CheckoutEnvironment::Test)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[1].method, "PUT");
assert_eq!(
seen[1].url,
"https://api.test/checkout-methods/pro_1/test/entries?merchant_id=mer_1"
);
assert_eq!(
seen[1].body_json(),
json!({"entries": [
{"key": "crypto", "label": "Pay with crypto", "kind": "methods",
"methods": [{"kind": "method", "connector": "cryptomus", "method": "crypto"}],
"theme": "dark", "entry_surprise": 1},
{"key": "card", "label": "Card form", "kind": "card", "other_entry": "crypto"}
]})
);
}
#[tokio::test]
async fn clear_entries_deletes_the_test_entries() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"profile_id":"pro_1","test_mode":true,"entries":[],"surprise_field":1}"#,
)]);
let out = client
.checkout_methods()
.clear_entries("mer_1", "pro_1", CheckoutEnvironment::Test)
.await
.unwrap();
assert!(out.test_mode);
assert!(out.entries.is_empty());
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/checkout-methods/pro_1/test/entries?merchant_id=mer_1"
);
}
#[test]
fn entries_validate_rejects_a_nested_colliding_extra_key() {
let mut method = CheckoutEntryMethod::provider_method("stripe", "apple_pay");
method.extra.insert("method".to_string(), json!("other"));
let req = CheckoutEntriesUpdateRequest::new(vec![
CheckoutEntry::new("e1", "Entry")
.kind("methods")
.method(method),
]);
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("CheckoutEntryMethod")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
let mut entry = CheckoutEntry::new("e1", "Entry");
entry.extra.insert("label".to_string(), json!("other"));
match CheckoutEntriesUpdateRequest::new(vec![entry])
.validate()
.unwrap_err()
{
DelopayError::InvalidRequest(msg) => assert!(msg.contains("`label`")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[test]
fn redirect_rules_validate_rejects_a_colliding_extra_key() {
let mut req = CheckoutRedirectRulesTestRequest::new(json!({}), 1, "EUR");
req.extra.insert("amount".to_string(), json!(2));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("amount")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[test]
fn entry_and_redirect_rule_named_fields_are_complete() {
fn assert_covered(value: Value, named: &[&str], list: &str) {
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
named.contains(&key.as_str()),
"{list} is missing wire key `{key}`"
);
}
}
let method = CheckoutEntryMethod {
kind: Some("method".to_string()),
group_id: Some("g".to_string()),
connector: Some("stripe".to_string()),
method: Some("apple_pay".to_string()),
capability: Some("wallet.apple_pay".to_string()),
extra: serde_json::Map::new(),
};
assert_covered(
serde_json::to_value(&method).unwrap(),
CHECKOUT_ENTRY_METHOD_NAMED,
"CHECKOUT_ENTRY_METHOD_NAMED",
);
let entry = CheckoutEntry::new("k", "l")
.kind("methods")
.method(method)
.theme("dark")
.other_entry("o");
assert_covered(
serde_json::to_value(&entry).unwrap(),
CHECKOUT_ENTRY_NAMED,
"CHECKOUT_ENTRY_NAMED",
);
assert_covered(
serde_json::to_value(CheckoutEntriesUpdateRequest::new(vec![entry])).unwrap(),
CHECKOUT_ENTRIES_UPDATE_REQUEST_NAMED,
"CHECKOUT_ENTRIES_UPDATE_REQUEST_NAMED",
);
let mut cap_states = serde_json::Map::new();
cap_states.insert("mca_1".to_string(), json!("exhausted"));
let mut metadata = std::collections::BTreeMap::new();
metadata.insert("a".to_string(), "b".to_string());
let rules = CheckoutRedirectRulesTestRequest::new(json!({}), 1, "EUR")
.country("DE")
.device("mobile")
.metadata(metadata)
.cap_states(cap_states.clone())
.health_states(cap_states);
assert_covered(
serde_json::to_value(rules).unwrap(),
CHECKOUT_REDIRECT_RULES_TEST_REQUEST_NAMED,
"CHECKOUT_REDIRECT_RULES_TEST_REQUEST_NAMED",
);
}
fn keyed_client_over_503s() -> (
crate::Delopay,
std::sync::Arc<crate::http::mock::MockTransport>,
) {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(503, "{}"), Step::status(503, "{}")],
2,
);
(client.with_idempotency_key("client-wide-key"), mock)
}
fn assert_sent_once_unkeyed(mock: &crate::http::mock::MockTransport) {
assert_eq!(mock.call_count(), 1, "a 503 was replayed");
assert!(
!mock.seen.lock().unwrap()[0].had_idempotency_key(),
"the client-wide key was inherited"
);
}
#[tokio::test]
async fn new_writes_do_not_inherit_the_client_key() {
let (client, mock) = keyed_client_over_503s();
let params = CheckoutRedirectRulesTestRequest::new(json!({}), 1, "EUR");
assert!(
client
.checkout_methods()
.test_redirect_rules("mer_1", "pro_1", ¶ms, CheckoutEnvironment::Live)
.await
.is_err()
);
assert_sent_once_unkeyed(&mock);
}
}