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::connector::{
AirwallexApplePayDomainsRegisterResponse, ConnectorBuyerMailResponse,
ConnectorConsolidationResponse, ConnectorCurrencyConversionSetting,
ConnectorCurrencyPolicyResponse, ConnectorHealthResponse, ConnectorResponse,
ConnectorShopsResponse, ConnectorWebhookListResponse, ConnectorWebhookRegisterResponse,
ConnectorWebhookSyncResponse, ProviderWebhookCreateResponse, ProviderWebhookDeleteResult,
ProviderWebhookEndpoint, ProviderWebhookListResponse, ProviderWebhookReplacePreviewResponse,
ProviderWebhookReplaceResponse, StripePaymentMethodDomainsRegisterResponse,
VaultOutagesResponse, VaultRoutesApplyResponse, VaultRoutesPreviewResponse,
VaultVerificationResponse, WebhookAddressFormat, WebhookAddressPreviewResponse,
WebhookAddressResponse, WhopApplePayDomainsRegisterResponse,
};
use crate::core::panes::PanesCatalogResponse;
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Connectors {
inner: Arc<Inner>,
}
impl Connectors {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn create(
&self,
account_id: &str,
params: &ConnectorCreateRequest,
) -> Result<ConnectorResponse> {
params.validate()?;
let path = format!("/account/{}/connectors", encode_segment(account_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn panes_catalog(&self, account_id: &str) -> Result<PanesCatalogResponse> {
let path = format!(
"/account/{}/connectors/native-panes/catalog",
encode_segment(account_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn retrieve(
&self,
account_id: &str,
connector_id: &str,
) -> Result<ConnectorResponse> {
let path = format!(
"/account/{}/connectors/{}",
encode_segment(account_id),
encode_segment(connector_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn list(&self, account_id: &str) -> Result<Vec<ConnectorResponse>> {
let path = format!("/account/{}/connectors", encode_segment(account_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update(
&self,
account_id: &str,
connector_id: &str,
params: &ConnectorUpdateRequest,
) -> Result<ConnectorResponse> {
params.validate()?;
let path = format!(
"/account/{}/connectors/{}",
encode_segment(account_id),
encode_segment(connector_id)
);
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn delete(&self, account_id: &str, connector_id: &str) -> Result<ConnectorResponse> {
let path = format!(
"/account/{}/connectors/{}",
encode_segment(account_id),
encode_segment(connector_id)
);
self.inner
.request(HttpMethod::Delete, &path, None, &[], None)
.await
}
pub async fn register_webhook(
&self,
merchant_id: &str,
connector_id: &str,
params: Option<&ConnectorWebhookRegisterRequest>,
) -> Result<ConnectorWebhookRegisterResponse> {
let path = format!(
"/account/{}/connectors/webhooks/{}",
encode_segment(merchant_id),
encode_segment(connector_id)
);
match params {
None => {
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
Some(p) => {
let body = to_json_vec(p)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
}
}
pub async fn webhook(
&self,
merchant_id: &str,
connector_id: &str,
) -> Result<ConnectorWebhookListResponse> {
let path = format!(
"/account/{}/connectors/webhooks/{}",
encode_segment(merchant_id),
encode_segment(connector_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn sync_webhook_events(
&self,
merchant_id: &str,
connector_id: &str,
) -> Result<ConnectorWebhookSyncResponse> {
let path = format!(
"/account/{}/connectors/webhooks/{}/sync-events",
encode_segment(merchant_id),
encode_segment(connector_id)
);
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn health(
&self,
account_id: &str,
connector_id: &str,
params: Option<&ConnectorHealthParams>,
) -> Result<ConnectorHealthResponse> {
let path = format!(
"/account/{}/connectors/{}/health",
encode_segment(account_id),
encode_segment(connector_id)
);
let query = params
.map(ConnectorHealthParams::to_query)
.unwrap_or_default();
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn register_airwallex_apple_pay_domains(
&self,
merchant_id: &str,
connector_id: &str,
params: &AirwallexApplePayDomainsRegisterRequest,
) -> Result<AirwallexApplePayDomainsRegisterResponse> {
let path = format!(
"/account/{}/connectors/{}/airwallex/apple-pay-domains",
encode_segment(merchant_id),
encode_segment(connector_id)
);
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn register_stripe_payment_method_domains(
&self,
merchant_id: &str,
connector_id: &str,
params: &StripePaymentMethodDomainsRegisterRequest,
) -> Result<StripePaymentMethodDomainsRegisterResponse> {
let path = format!(
"/account/{}/connectors/{}/stripe/payment-method-domains",
encode_segment(merchant_id),
encode_segment(connector_id)
);
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn list_payment_methods(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/account/payment-methods", None, &[], None)
.await
}
pub async fn list_by_profile(&self, account_id: &str) -> Result<Vec<ConnectorResponse>> {
let path = format!("/account/{}/profile/connectors", encode_segment(account_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn retrieve_buyer_email_preference(
&self,
merchant_id: &str,
connector_id: &str,
test_mode: bool,
) -> Result<ConnectorBuyerMailResponse> {
let path = connector_path(merchant_id, connector_id, "/buyer-email-preference");
let query = [("test_mode", test_mode.to_string())];
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn update_buyer_email_preference(
&self,
merchant_id: &str,
connector_id: &str,
params: &ConnectorBuyerMailUpdateRequest,
) -> Result<ConnectorBuyerMailResponse> {
let path = connector_path(merchant_id, connector_id, "/buyer-email-preference");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn add_shops(
&self,
account_id: &str,
connector_id: &str,
params: &ConnectorShopsAddRequest,
) -> Result<ConnectorShopsResponse> {
let path = connector_path(account_id, connector_id, "/shops");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn consolidate(
&self,
account_id: &str,
connector_id: &str,
params: &ConnectorConsolidationRequest,
) -> Result<ConnectorConsolidationResponse> {
params.validate()?;
let path = connector_path(account_id, connector_id, "/consolidate");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn set_shop_disabled(
&self,
account_id: &str,
connector_id: &str,
profile_id: &str,
params: &ConnectorShopUpdateRequest,
) -> Result<ConnectorShopsResponse> {
params.validate()?;
let path = connector_shop_path(account_id, connector_id, profile_id, "");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn remove_shop(
&self,
account_id: &str,
connector_id: &str,
profile_id: &str,
) -> Result<ConnectorShopsResponse> {
let path = connector_shop_path(account_id, connector_id, profile_id, "");
self.inner
.request_body_keyed_with_query(HttpMethod::Delete, &path, None, &[], None)
.await
}
pub async fn currencies(
&self,
account_id: &str,
connector_id: &str,
) -> Result<ConnectorCurrencyPolicyResponse> {
let path = connector_path(account_id, connector_id, "/currencies");
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn set_currencies(
&self,
account_id: &str,
connector_id: &str,
params: &ConnectorCurrencyPolicyUpdateRequest,
) -> Result<ConnectorCurrencyPolicyResponse> {
params.validate()?;
let path = connector_path(account_id, connector_id, "/currencies");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn set_shop_currencies(
&self,
account_id: &str,
connector_id: &str,
profile_id: &str,
params: &ConnectorCurrencyPolicyUpdateRequest,
) -> Result<ConnectorCurrencyPolicyResponse> {
params.validate()?;
let path = connector_shop_path(account_id, connector_id, profile_id, "/currencies");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn verify_vault(
&self,
account_id: &str,
connector_id: &str,
params: &VaultVerifyRequest,
) -> Result<VaultVerificationResponse> {
let path = connector_path(account_id, connector_id, "/vault/verify");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn vault_outages(&self, account_id: &str) -> Result<VaultOutagesResponse> {
let path = format!("/account/{}/vault/outages", encode_segment(account_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn preview_vault_routes(
&self,
account_id: &str,
connector_id: &str,
params: &VaultRoutesPreviewRequest,
) -> Result<VaultRoutesPreviewResponse> {
params.validate()?;
let path = connector_path(account_id, connector_id, "/vault/routes/preview");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn apply_vault_routes(
&self,
account_id: &str,
connector_id: &str,
params: &VaultRoutesApplyRequest,
) -> Result<VaultRoutesApplyResponse> {
params.validate()?;
let path = connector_path(account_id, connector_id, "/vault/routes/apply");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn register_whop_apple_pay_domains(
&self,
merchant_id: &str,
connector_id: &str,
params: &WhopApplePayDomainsRegisterRequest,
) -> Result<WhopApplePayDomainsRegisterResponse> {
let path = connector_path(merchant_id, connector_id, "/whop/apple-pay-domains");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn webhook_address(
&self,
merchant_id: &str,
connector_id: &str,
) -> Result<WebhookAddressResponse> {
let path = webhook_path(merchant_id, connector_id, "/address");
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn preview_webhook_address(
&self,
merchant_id: &str,
connector_id: &str,
params: &WebhookAddressRequest,
) -> Result<WebhookAddressPreviewResponse> {
params.validate()?;
let path = webhook_path(merchant_id, connector_id, "/address/preview");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn update_webhook_address(
&self,
merchant_id: &str,
connector_id: &str,
params: &WebhookAddressRequest,
) -> Result<WebhookAddressResponse> {
params.validate()?;
let path = webhook_path(merchant_id, connector_id, "/address");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn list_provider_webhooks(
&self,
merchant_id: &str,
connector_id: &str,
environment: &str,
) -> Result<ProviderWebhookListResponse> {
let path = webhook_path(merchant_id, connector_id, "/provider");
let query = [("environment", environment.to_string())];
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn create_provider_webhook(
&self,
merchant_id: &str,
connector_id: &str,
params: &ProviderWebhookCreateRequest,
) -> Result<ProviderWebhookCreateResponse> {
let path = webhook_path(merchant_id, connector_id, "/provider");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn update_provider_webhook(
&self,
merchant_id: &str,
connector_id: &str,
webhook_id: &str,
params: &ProviderWebhookUpdateRequest,
) -> Result<ProviderWebhookEndpoint> {
let suffix = format!("/provider/{}", encode_segment(webhook_id));
let path = webhook_path(merchant_id, connector_id, &suffix);
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Patch, &path, Some(&body), &[], None)
.await
}
pub async fn delete_provider_webhook(
&self,
merchant_id: &str,
connector_id: &str,
webhook_id: &str,
params: &ProviderWebhookDeleteRequest,
) -> Result<ProviderWebhookDeleteResult> {
let suffix = format!("/provider/{}/delete", encode_segment(webhook_id));
let path = webhook_path(merchant_id, connector_id, &suffix);
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn preview_provider_webhook_replace(
&self,
merchant_id: &str,
connector_id: &str,
environment: &str,
) -> Result<ProviderWebhookReplacePreviewResponse> {
let path = webhook_path(merchant_id, connector_id, "/provider/replace");
let query = [("environment", environment.to_string())];
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn replace_provider_webhooks(
&self,
merchant_id: &str,
connector_id: &str,
params: &ProviderWebhookReplaceRequest,
) -> Result<ProviderWebhookReplaceResponse> {
let path = webhook_path(merchant_id, connector_id, "/provider/replace");
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
}
fn connector_path(account_id: &str, connector_id: &str, suffix: &str) -> String {
format!(
"/account/{}/connectors/{}{suffix}",
encode_segment(account_id),
encode_segment(connector_id)
)
}
fn connector_shop_path(
account_id: &str,
connector_id: &str,
profile_id: &str,
suffix: &str,
) -> String {
format!(
"{}/{}{suffix}",
connector_path(account_id, connector_id, "/shops"),
encode_segment(profile_id)
)
}
fn webhook_path(merchant_id: &str, connector_id: &str, suffix: &str) -> String {
format!(
"/account/{}/connectors/webhooks/{}{suffix}",
encode_segment(merchant_id),
encode_segment(connector_id)
)
}
fn reject_extra_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(())
}
#[derive(Debug, Clone, Serialize)]
pub struct ConnectorBuyerMailUpdateRequest {
pub test_mode: bool,
pub expected_provider_account_id: String,
pub send_customer_emails: bool,
pub expected_send_customer_emails: bool,
pub confirmed_account_wide: bool,
}
impl ConnectorBuyerMailUpdateRequest {
pub fn new(
test_mode: bool,
expected_provider_account_id: impl Into<String>,
expected_send_customer_emails: bool,
send_customer_emails: bool,
) -> Self {
Self {
test_mode,
expected_provider_account_id: expected_provider_account_id.into(),
send_customer_emails,
expected_send_customer_emails,
confirmed_account_wide: true,
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorShopsAddRequest {
pub profile_ids: Vec<String>,
}
impl ConnectorShopsAddRequest {
pub fn new<I, S>(profile_ids: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self {
profile_ids: profile_ids.into_iter().map(Into::into).collect(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorConsolidationRequest {
pub merchant_connector_ids: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub preview_token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub choices: Option<std::collections::BTreeMap<String, String>>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl ConnectorConsolidationRequest {
pub fn new<I, S>(merchant_connector_ids: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self {
merchant_connector_ids: merchant_connector_ids.into_iter().map(Into::into).collect(),
..Default::default()
}
}
#[must_use]
pub fn dry_run(mut self, dry_run: bool) -> Self {
self.dry_run = Some(dry_run);
self
}
#[must_use]
pub fn preview_token(mut self, preview_token: impl Into<String>) -> Self {
self.preview_token = Some(preview_token.into());
self
}
#[must_use]
pub fn choice(
mut self,
setting: impl Into<String>,
merchant_connector_id: impl Into<String>,
) -> Self {
self.choices
.get_or_insert_with(Default::default)
.insert(setting.into(), merchant_connector_id.into());
self
}
}
const CONNECTOR_CONSOLIDATION_REQUEST_NAMED: &[&str] = &[
"merchant_connector_ids",
"dry_run",
"preview_token",
"choices",
];
impl ValidateRequest for ConnectorConsolidationRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
CONNECTOR_CONSOLIDATION_REQUEST_NAMED,
"ConnectorConsolidationRequest",
)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorShopUpdateRequest {
pub disabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl ConnectorShopUpdateRequest {
pub fn new(disabled: bool) -> Self {
Self {
disabled,
..Default::default()
}
}
#[must_use]
pub fn reason(mut self, reason: impl Into<String>) -> Self {
self.reason = Some(reason.into());
self
}
}
const CONNECTOR_SHOP_UPDATE_REQUEST_NAMED: &[&str] = &["disabled", "reason"];
impl ValidateRequest for ConnectorShopUpdateRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
CONNECTOR_SHOP_UPDATE_REQUEST_NAMED,
"ConnectorShopUpdateRequest",
)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorCurrencyPolicyUpdateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_currencies: Option<Option<Vec<String>>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub conversion: Option<Option<ConnectorCurrencyConversionSetting>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl ConnectorCurrencyPolicyUpdateRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn allowed_currencies<I, S>(mut self, currencies: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.allowed_currencies = Some(Some(currencies.into_iter().map(Into::into).collect()));
self
}
#[must_use]
pub fn allow_every_currency(mut self) -> Self {
self.allowed_currencies = Some(None);
self
}
#[must_use]
pub fn follow_account_currencies(self) -> Self {
self.allow_every_currency()
}
#[must_use]
pub fn conversion(mut self, conversion: ConnectorCurrencyConversionSetting) -> Self {
self.conversion = Some(Some(conversion));
self
}
#[must_use]
pub fn follow_account_conversion(mut self) -> Self {
self.conversion = Some(None);
self
}
#[must_use]
pub fn dry_run(mut self, dry_run: bool) -> Self {
self.dry_run = Some(dry_run);
self
}
}
const CONNECTOR_CURRENCY_POLICY_UPDATE_REQUEST_NAMED: &[&str] =
&["allowed_currencies", "conversion", "dry_run"];
impl ValidateRequest for ConnectorCurrencyPolicyUpdateRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
CONNECTOR_CURRENCY_POLICY_UPDATE_REQUEST_NAMED,
"ConnectorCurrencyPolicyUpdateRequest",
)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct VaultVerifyRequest {
pub profile_id: String,
}
impl VaultVerifyRequest {
pub fn new(profile_id: impl Into<String>) -> Self {
Self {
profile_id: profile_id.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct VaultRoutesPreviewRequest {
pub profile_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl VaultRoutesPreviewRequest {
pub fn new(profile_id: impl Into<String>) -> Self {
Self {
profile_id: profile_id.into(),
..Default::default()
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
}
const VAULT_ROUTES_PREVIEW_REQUEST_NAMED: &[&str] = &["profile_id", "environment"];
impl ValidateRequest for VaultRoutesPreviewRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
VAULT_ROUTES_PREVIEW_REQUEST_NAMED,
"VaultRoutesPreviewRequest",
)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct VaultRoutesApplyRequest {
pub profile_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
pub expected_current_fingerprint: Option<String>,
pub expected_desired_fingerprint: String,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl VaultRoutesApplyRequest {
pub fn new(
profile_id: impl Into<String>,
expected_current_fingerprint: Option<String>,
expected_desired_fingerprint: impl Into<String>,
) -> Self {
Self {
profile_id: profile_id.into(),
environment: None,
expected_current_fingerprint,
expected_desired_fingerprint: expected_desired_fingerprint.into(),
extra: serde_json::Map::new(),
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
}
const VAULT_ROUTES_APPLY_REQUEST_NAMED: &[&str] = &[
"profile_id",
"environment",
"expected_current_fingerprint",
"expected_desired_fingerprint",
];
impl ValidateRequest for VaultRoutesApplyRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
VAULT_ROUTES_APPLY_REQUEST_NAMED,
"VaultRoutesApplyRequest",
)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct WhopApplePayDomainsRegisterRequest {
pub urls: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
}
impl WhopApplePayDomainsRegisterRequest {
pub fn new<I, S>(urls: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self {
urls: urls.into_iter().map(Into::into).collect(),
environment: None,
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct WebhookAddressRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
pub mode: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub alias: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<WebhookAddressFormat>,
#[serde(skip_serializing_if = "Option::is_none")]
pub regenerate: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub confirm_shared: Option<bool>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl WebhookAddressRequest {
pub fn new(mode: impl Into<String>) -> Self {
Self {
mode: mode.into(),
..Default::default()
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
#[must_use]
pub fn alias(mut self, alias: impl Into<String>) -> Self {
self.alias = Some(alias.into());
self
}
#[must_use]
pub fn format(mut self, format: WebhookAddressFormat) -> Self {
self.format = Some(format);
self
}
#[must_use]
pub fn regenerate(mut self, regenerate: bool) -> Self {
self.regenerate = Some(regenerate);
self
}
#[must_use]
pub fn confirm_shared(mut self, confirm_shared: bool) -> Self {
self.confirm_shared = Some(confirm_shared);
self
}
}
const WEBHOOK_ADDRESS_REQUEST_NAMED: &[&str] = &[
"environment",
"mode",
"alias",
"format",
"regenerate",
"confirm_shared",
];
impl ValidateRequest for WebhookAddressRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
WEBHOOK_ADDRESS_REQUEST_NAMED,
"WebhookAddressRequest",
)
}
}
#[derive(Clone, Serialize)]
pub struct ProviderWebhookCreateRequest {
pub environment: String,
pub url: String,
pub events: Vec<String>,
}
impl ProviderWebhookCreateRequest {
pub fn new<I, S>(environment: impl Into<String>, url: impl Into<String>, events: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self {
environment: environment.into(),
url: url.into(),
events: events.into_iter().map(Into::into).collect(),
}
}
}
impl std::fmt::Debug for ProviderWebhookCreateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ProviderWebhookCreateRequest")
.field("environment", &self.environment)
.field("url", &REDACTED)
.field("events", &self.events)
.finish()
}
}
#[derive(Clone, Serialize)]
pub struct ProviderWebhookUpdateRequest {
pub environment: String,
pub fingerprint: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub events: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
impl ProviderWebhookUpdateRequest {
pub fn new(environment: impl Into<String>, fingerprint: impl Into<String>) -> Self {
Self {
environment: environment.into(),
fingerprint: fingerprint.into(),
url: None,
events: None,
enabled: None,
}
}
#[must_use]
pub fn url(mut self, url: impl Into<String>) -> Self {
self.url = Some(url.into());
self
}
#[must_use]
pub fn events<I, S>(mut self, events: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.events = Some(events.into_iter().map(Into::into).collect());
self
}
#[must_use]
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled = Some(enabled);
self
}
}
impl std::fmt::Debug for ProviderWebhookUpdateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ProviderWebhookUpdateRequest")
.field("environment", &self.environment)
.field("fingerprint", &self.fingerprint)
.field("url", &self.url.as_ref().map(|_| REDACTED))
.field("events", &self.events)
.field("enabled", &self.enabled)
.finish()
}
}
#[derive(Debug, Clone, Serialize)]
pub struct ProviderWebhookDeleteRequest {
pub environment: String,
pub fingerprint: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub confirm_managed: Option<bool>,
}
impl ProviderWebhookDeleteRequest {
pub fn new(environment: impl Into<String>, fingerprint: impl Into<String>) -> Self {
Self {
environment: environment.into(),
fingerprint: fingerprint.into(),
confirm_managed: None,
}
}
#[must_use]
pub fn confirm_managed(mut self, confirm: bool) -> Self {
self.confirm_managed = Some(confirm);
self
}
}
#[derive(Debug, Clone, Serialize)]
pub struct ProviderWebhookReplaceRequest {
pub environment: String,
pub confirmed: Vec<ProviderWebhookConfirmation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_delete_first: Option<bool>,
}
impl ProviderWebhookReplaceRequest {
pub fn new(
environment: impl Into<String>,
confirmed: Vec<ProviderWebhookConfirmation>,
) -> Self {
Self {
environment: environment.into(),
confirmed,
accept_delete_first: None,
}
}
#[must_use]
pub fn accept_delete_first(mut self, accept: bool) -> Self {
self.accept_delete_first = Some(accept);
self
}
}
#[derive(Debug, Clone, Serialize)]
pub struct ProviderWebhookConfirmation {
pub id: String,
pub fingerprint: String,
}
impl ProviderWebhookConfirmation {
pub fn new(id: impl Into<String>, fingerprint: impl Into<String>) -> Self {
Self {
id: id.into(),
fingerprint: fingerprint.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct ConnectorCreateRequest {
pub connector_type: String,
pub connector_name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_label: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_account_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_methods_enabled: Option<Vec<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(skip_serializing_if = "Option::is_none")]
pub disabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_webhook_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_merchant_data: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_methods_enabled_sandbox: Option<Vec<Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhook_address: Option<ConnectorCreateWebhookAddress>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const REDACTED: &str = "[redacted]";
fn redact(v: Option<&Value>) -> Option<&'static str> {
v.map(|_| REDACTED)
}
impl std::fmt::Debug for ConnectorCreateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ConnectorCreateRequest")
.field("connector_type", &self.connector_type)
.field("connector_name", &self.connector_name)
.field("connector_label", &self.connector_label)
.field("profile_id", &self.profile_id)
.field(
"connector_account_details",
&redact(self.connector_account_details.as_ref()),
)
.field("payment_methods_enabled", &self.payment_methods_enabled)
.field("metadata", &self.metadata)
.field("test_mode", &self.test_mode)
.field("disabled", &self.disabled)
.field(
"connector_webhook_details",
&redact(self.connector_webhook_details.as_ref()),
)
.field(
"additional_merchant_data",
&redact(self.additional_merchant_data.as_ref()),
)
.field("status", &self.status)
.field(
"payment_methods_enabled_sandbox",
&self.payment_methods_enabled_sandbox,
)
.field("webhook_address", &self.webhook_address)
.field("extra", &self.extra)
.finish()
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorCreateWebhookAddress {
pub mode: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub alias: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<WebhookAddressFormat>,
}
impl ConnectorCreateWebhookAddress {
pub fn new(mode: impl Into<String>) -> Self {
Self {
mode: mode.into(),
..Default::default()
}
}
#[must_use]
pub fn alias(mut self, alias: impl Into<String>) -> Self {
self.alias = Some(alias.into());
self
}
#[must_use]
pub fn format(mut self, format: WebhookAddressFormat) -> Self {
self.format = Some(format);
self
}
}
const CONNECTOR_CREATE_REQUEST_NAMED: &[&str] = &[
"connector_type",
"connector_name",
"connector_label",
"profile_id",
"connector_account_details",
"payment_methods_enabled",
"metadata",
"test_mode",
"disabled",
"connector_webhook_details",
"additional_merchant_data",
"status",
"payment_methods_enabled_sandbox",
"webhook_address",
];
impl ValidateRequest for ConnectorCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CONNECTOR_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on ConnectorCreateRequest"
)));
}
}
Ok(())
}
}
impl ConnectorCreateRequest {
pub fn new(connector_type: impl Into<String>, connector_name: impl Into<String>) -> Self {
Self {
connector_type: connector_type.into(),
connector_name: connector_name.into(),
..Default::default()
}
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
#[must_use]
pub fn connector_label(mut self, label: impl Into<String>) -> Self {
self.connector_label = Some(label.into());
self
}
#[must_use]
pub fn connector_account_details(mut self, details: Value) -> Self {
self.connector_account_details = Some(details);
self
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = Some(test_mode);
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct ConnectorUpdateRequest {
pub connector_type: String,
pub status: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_label: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_account_details: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_methods_enabled: Option<Vec<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(skip_serializing_if = "Option::is_none")]
pub disabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_webhook_details: Option<ConnectorWebhookDetailsUpdate>,
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_merchant_data: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_methods_enabled_sandbox: Option<Vec<Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_methods_enabled_sandbox_follows_live: Option<bool>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Clone, Default, Serialize)]
pub struct ConnectorWebhookDetailsUpdate {
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_secret: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_secret: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sandbox_merchant_secret: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sandbox_additional_secret: Option<String>,
}
impl std::fmt::Debug for ConnectorWebhookDetailsUpdate {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mask = |v: &Option<String>| v.as_ref().map(|_| REDACTED);
f.debug_struct("ConnectorWebhookDetailsUpdate")
.field("merchant_secret", &mask(&self.merchant_secret))
.field("additional_secret", &mask(&self.additional_secret))
.field(
"sandbox_merchant_secret",
&mask(&self.sandbox_merchant_secret),
)
.field(
"sandbox_additional_secret",
&mask(&self.sandbox_additional_secret),
)
.finish()
}
}
impl std::fmt::Debug for ConnectorUpdateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ConnectorUpdateRequest")
.field("connector_type", &self.connector_type)
.field("status", &self.status)
.field("connector_label", &self.connector_label)
.field(
"connector_account_details",
&redact(self.connector_account_details.as_ref()),
)
.field("payment_methods_enabled", &self.payment_methods_enabled)
.field("metadata", &self.metadata)
.field("test_mode", &self.test_mode)
.field("disabled", &self.disabled)
.field("connector_webhook_details", &self.connector_webhook_details)
.field(
"additional_merchant_data",
&redact(self.additional_merchant_data.as_ref()),
)
.field(
"payment_methods_enabled_sandbox",
&self.payment_methods_enabled_sandbox,
)
.field(
"payment_methods_enabled_sandbox_follows_live",
&self.payment_methods_enabled_sandbox_follows_live,
)
.field("extra", &self.extra)
.finish()
}
}
const CONNECTOR_UPDATE_REQUEST_NAMED: &[&str] = &[
"connector_type",
"status",
"connector_label",
"connector_account_details",
"payment_methods_enabled",
"metadata",
"test_mode",
"disabled",
"connector_webhook_details",
"additional_merchant_data",
"payment_methods_enabled_sandbox",
"payment_methods_enabled_sandbox_follows_live",
];
impl ValidateRequest for ConnectorUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CONNECTOR_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on ConnectorUpdateRequest"
)));
}
}
Ok(())
}
}
impl ConnectorUpdateRequest {
pub fn new(connector_type: impl Into<String>, status: impl Into<String>) -> Self {
Self {
connector_type: connector_type.into(),
status: status.into(),
..Default::default()
}
}
#[must_use]
pub fn connector_account_details(mut self, details: Value) -> Self {
self.connector_account_details = Some(details);
self
}
#[must_use]
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = Some(disabled);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConnectorWebhookRegisterRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhook_url: Option<String>,
}
impl ConnectorWebhookRegisterRequest {
pub fn all_events() -> Self {
Self {
event_type: Some(Value::String("all_events".to_string())),
..Default::default()
}
}
pub fn specific_event(event: impl Into<String>) -> Self {
Self {
event_type: Some(serde_json::json!({ "specific_event": event.into() })),
..Default::default()
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
#[must_use]
pub fn webhook_url(mut self, url: impl Into<String>) -> Self {
self.webhook_url = Some(url.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct StripePaymentMethodDomainsRegisterRequest {
pub urls: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
}
impl StripePaymentMethodDomainsRegisterRequest {
pub fn new<I, S>(urls: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self {
urls: urls.into_iter().map(Into::into).collect(),
environment: None,
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
}
#[derive(Debug, Clone, Default)]
pub struct ConnectorHealthParams {
pub test_mode: Option<bool>,
pub refresh: Option<bool>,
}
impl ConnectorHealthParams {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = Some(test_mode);
self
}
#[must_use]
pub fn refresh(mut self, refresh: bool) -> Self {
self.refresh = Some(refresh);
self
}
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.test_mode {
q.push(("test_mode", v.to_string()));
}
if let Some(v) = self.refresh {
q.push(("refresh", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct AirwallexApplePayDomainsRegisterRequest {
pub urls: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<String>,
}
impl AirwallexApplePayDomainsRegisterRequest {
pub fn new<I, S>(urls: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self {
urls: urls.into_iter().map(Into::into).collect(),
environment: None,
}
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const CONNECTOR_JSON: &str = r#"{
"merchant_connector_id": "mca_1",
"connector_type": "payment_processor",
"connector_name": "stripe",
"profile_id": "pro_1",
"status": "active"
}"#;
fn full_create_request() -> ConnectorCreateRequest {
ConnectorCreateRequest {
connector_type: "payment_processor".to_string(),
connector_name: "stripe".to_string(),
connector_label: Some("stripe_uk".to_string()),
profile_id: Some("pro_1".to_string()),
connector_account_details: Some(json!({"api_key": "sk_live_supersecret"})),
payment_methods_enabled: Some(vec![json!({"payment_method": "card"})]),
metadata: Some(json!({"team": "payments"})),
test_mode: Some(false),
disabled: Some(false),
connector_webhook_details: Some(json!({"merchant_secret": "whsec_topsecret"})),
additional_merchant_data: Some(json!({"acquirer": "acq_1"})),
status: Some("active".to_string()),
payment_methods_enabled_sandbox: Some(vec![json!({"payment_method": "card"})]),
webhook_address: Some(
ConnectorCreateWebhookAddress::new("custom")
.alias("shop-a")
.format(WebhookAddressFormat::new("wh", "alphanumeric", 16)),
),
extra: serde_json::Map::new(),
}
}
fn full_update_request() -> ConnectorUpdateRequest {
ConnectorUpdateRequest {
connector_type: "payment_processor".to_string(),
status: "active".to_string(),
connector_label: Some("stripe_uk".to_string()),
connector_account_details: Some(json!({"api_key": "sk_live_supersecret"})),
payment_methods_enabled: Some(vec![json!({"payment_method": "card"})]),
metadata: Some(json!({"team": "payments"})),
test_mode: Some(false),
disabled: Some(false),
connector_webhook_details: Some(ConnectorWebhookDetailsUpdate {
merchant_secret: Some("whsec_topsecret".to_string()),
additional_secret: None,
sandbox_merchant_secret: None,
sandbox_additional_secret: None,
}),
additional_merchant_data: Some(json!({"acquirer": "acq_1"})),
payment_methods_enabled_sandbox: Some(Vec::new()),
payment_methods_enabled_sandbox_follows_live: Some(false),
extra: serde_json::Map::new(),
}
}
#[tokio::test]
async fn panes_catalog_gets_the_routers_own_path_and_decodes() {
let (client, mock) = client_with(vec![Step::ok(
r#"{
"connectors": [{
"connector": "stripe",
"allowed_rails": ["wallet", "redirect"],
"methods": [{
"key": "klarna",
"rail": "redirect",
"payment_method": "pay_later",
"payment_method_type": "klarna",
"requires_billing_country": true
}]
}]
}"#,
)]);
let catalog = client.connectors().panes_catalog("acct/1").await.unwrap();
assert_eq!(catalog.connectors[0].connector, "stripe");
let method = &catalog.connectors[0].methods[0];
assert_eq!(method.payment_method, "pay_later");
assert!(method.requires_billing_country);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/account/acct%2F1/connectors/native-panes/catalog"
);
}
#[test]
fn connector_create_request_named_fields_are_complete() {
let value = serde_json::to_value(full_create_request()).unwrap();
assert_eq!(
value["webhook_address"],
json!({"mode": "custom", "alias": "shop-a",
"format": {"prefix": "wh", "style": "alphanumeric", "length": 16}})
);
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
CONNECTOR_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"CONNECTOR_CREATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn a_webhook_secret_update_sends_only_the_keys_it_sets() {
let request = ConnectorUpdateRequest {
connector_webhook_details: Some(ConnectorWebhookDetailsUpdate {
sandbox_merchant_secret: Some("whsec_sandbox".to_string()),
..ConnectorWebhookDetailsUpdate::default()
}),
..ConnectorUpdateRequest::new("payment_processor", "active")
};
let value = serde_json::to_value(&request).unwrap();
let details = value
.get("connector_webhook_details")
.and_then(Value::as_object)
.expect("the block serializes");
assert_eq!(
details.keys().collect::<Vec<_>>(),
["sandbox_merchant_secret"]
);
}
#[test]
fn an_explicit_empty_secret_is_sent_because_it_means_clear_it() {
let request = ConnectorUpdateRequest {
connector_webhook_details: Some(ConnectorWebhookDetailsUpdate {
merchant_secret: Some(String::new()),
..ConnectorWebhookDetailsUpdate::default()
}),
..ConnectorUpdateRequest::new("payment_processor", "active")
};
let value = serde_json::to_value(&request).unwrap();
assert_eq!(value["connector_webhook_details"]["merchant_secret"], "");
}
#[test]
fn a_webhook_secret_update_debug_redacts_every_secret() {
let printed = format!(
"{:?}",
ConnectorWebhookDetailsUpdate {
merchant_secret: Some("whsec_live".to_string()),
additional_secret: Some("whsec_extra".to_string()),
sandbox_merchant_secret: Some("whsec_sandbox".to_string()),
sandbox_additional_secret: Some("whsec_sandbox_extra".to_string()),
}
);
assert!(!printed.contains("whsec_"), "printed: {printed}");
assert_eq!(printed.matches(REDACTED).count(), 4);
}
#[test]
fn connector_update_request_named_fields_are_complete() {
let value = serde_json::to_value(full_update_request()).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
CONNECTOR_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"CONNECTOR_UPDATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn create_validate_rejects_colliding_extra_key() {
let mut req = ConnectorCreateRequest::new("payment_processor", "stripe");
req.extra.insert("profile_id".to_string(), json!("pro_2"));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("profile_id")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[test]
fn update_validate_rejects_colliding_extra_key() {
let mut req = ConnectorUpdateRequest::new("payment_processor", "active");
req.extra.insert("status".to_string(), json!("inactive"));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
#[test]
fn debug_redacts_connector_credentials() {
let rendered = format!("{:?}", full_create_request());
assert!(!rendered.contains("sk_live_supersecret"), "{rendered}");
assert!(!rendered.contains("whsec_topsecret"), "{rendered}");
assert!(!rendered.contains("acq_1"), "{rendered}");
assert!(rendered.contains("connector_account_details: Some(\"[redacted]\")"));
assert!(rendered.contains("stripe"), "{rendered}");
let rendered = format!("{:?}", full_update_request());
assert!(!rendered.contains("sk_live_supersecret"), "{rendered}");
assert!(!rendered.contains("whsec_topsecret"), "{rendered}");
assert!(!rendered.contains("acq_1"), "{rendered}");
assert!(rendered.contains("connector_account_details: Some(\"[redacted]\")"));
}
#[test]
fn debug_shows_none_for_unset_credentials() {
let rendered = format!(
"{:?}",
ConnectorCreateRequest::new("payment_processor", "stripe")
);
assert!(
rendered.contains("connector_account_details: None"),
"{rendered}"
);
}
#[tokio::test]
async fn create_posts_to_the_account_connectors_path() {
let (client, mock) = client_with(vec![Step::ok(CONNECTOR_JSON)]);
let req = ConnectorCreateRequest::new("payment_processor", "stripe")
.profile_id("pro_1")
.connector_account_details(json!({"api_key": "sk_test"}));
let created = client.connectors().create("mer/1", &req).await.unwrap();
assert_eq!(created.merchant_connector_id, "mca_1");
assert_eq!(created.connector_name.as_deref(), Some("stripe"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/account/mer%2F1/connectors");
let body = seen[0].body_json();
assert_eq!(body["connector_name"], "stripe");
assert_eq!(body["connector_account_details"]["api_key"], "sk_test");
}
#[tokio::test]
async fn retrieve_list_and_delete_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(CONNECTOR_JSON),
Step::ok("[]"),
Step::ok(CONNECTOR_JSON),
]);
let connectors = client.connectors();
let retrieved = connectors.retrieve("mer_1", "mca/1").await.unwrap();
assert_eq!(retrieved.status.as_deref(), Some("active"));
assert!(connectors.list("mer_1").await.unwrap().is_empty());
connectors.delete("mer_1", "mca_1").await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/account/mer_1/connectors/mca%2F1")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("GET", "https://api.test/account/mer_1/connectors")
);
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("DELETE", "https://api.test/account/mer_1/connectors/mca_1")
);
}
#[tokio::test]
async fn update_posts_the_status_to_the_connector_path() {
let (client, mock) = client_with(vec![Step::ok(CONNECTOR_JSON)]);
let req = ConnectorUpdateRequest::new("payment_processor", "inactive").disabled(true);
client
.connectors()
.update("mer_1", "mca_1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1"
);
let body = seen[0].body_json();
assert_eq!(body["status"], "inactive");
assert_eq!(body["disabled"], true);
}
#[tokio::test]
async fn register_webhook_omits_the_body_when_no_params() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"webhook_registration_status":"success"}"#,
)]);
let registered = client
.connectors()
.register_webhook("mer_1", "mca_1", None)
.await
.unwrap();
assert_eq!(registered.webhook_registration_status, "success");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/webhooks/mca_1"
);
assert!(seen[0].body.is_none(), "expected no request body");
}
#[tokio::test]
async fn register_webhook_sends_a_specific_event_scope() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"webhook_registration_status":"success"}"#,
)]);
let req = ConnectorWebhookRegisterRequest::specific_event("payment_intent.succeeded")
.environment("sandbox");
client
.connectors()
.register_webhook("mer_1", "mca_1", Some(&req))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let body = seen[0].body_json();
assert_eq!(
body["event_type"]["specific_event"],
"payment_intent.succeeded"
);
assert_eq!(body["environment"], "sandbox");
}
#[tokio::test]
async fn webhook_and_payment_methods_get_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(r#"{"connector":"stripe","webhooks":[{"connector_webhook_id":"we_1"}]}"#),
Step::ok("[]"),
]);
let connectors = client.connectors();
let listed = connectors.webhook("mer_1", "mca_1").await.unwrap();
assert_eq!(listed.connector, "stripe");
assert_eq!(listed.webhooks.len(), 1);
assert_eq!(listed.webhooks[0].connector_webhook_id, "we_1");
connectors.list_payment_methods().await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
(
"GET",
"https://api.test/account/mer_1/connectors/webhooks/mca_1"
)
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("GET", "https://api.test/account/payment-methods")
);
}
#[tokio::test]
async fn sync_webhook_events_posts_to_the_sync_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{
"connector": "stripe",
"expected_events": ["refund.succeeded"],
"endpoints": [
{"connector_webhook_id":"we_1","updated":true,"added_events":["refund.succeeded"]}
]
}"#,
)]);
let synced = client
.connectors()
.sync_webhook_events("mer_1", "mca_1")
.await
.unwrap();
assert_eq!(synced.endpoints[0].added_events, ["refund.succeeded"]);
assert!(synced.endpoints[0].updated);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/webhooks/mca_1/sync-events"
);
assert!(seen[0].body.is_none(), "expected no request body");
}
#[tokio::test]
async fn register_stripe_payment_method_domains_sends_urls_and_environment() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"environment":"sandbox","results":[{"url":"https://shop.example","status":"registered"}]}"#,
)]);
let req = StripePaymentMethodDomainsRegisterRequest::new(["https://shop.example"])
.environment("sandbox");
let registered = client
.connectors()
.register_stripe_payment_method_domains("mer_1", "mca_1", &req)
.await
.unwrap();
assert_eq!(registered.results[0].status.as_deref(), Some("registered"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/stripe/payment-method-domains"
);
let body = seen[0].body_json();
assert_eq!(body["urls"][0], "https://shop.example");
assert_eq!(body["environment"], "sandbox");
}
#[tokio::test]
async fn register_stripe_payment_method_domains_omits_an_unset_environment() {
let (client, mock) = client_with(vec![Step::ok(r#"{"environment":"live","results":[]}"#)]);
let req = StripePaymentMethodDomainsRegisterRequest::new(["shop.example"]);
client
.connectors()
.register_stripe_payment_method_domains("mer_1", "mca_1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let body = seen[0].body_json();
assert!(body.get("environment").is_none(), "{body}");
}
#[tokio::test]
async fn health_gets_the_connector_health_path_with_its_options() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"merchant_connector_id":"mca_1","connector":"stripe","test_mode":false,"state":"unknown","unknown_reason":"processor_unreachable","probed_at":"2026-09-12T00:00:00Z"}"#,
)]);
let out = client
.connectors()
.health(
"mer_1",
"mca_1",
Some(&ConnectorHealthParams::new().test_mode(false).refresh(true)),
)
.await
.unwrap();
assert_eq!(out.state, "unknown");
assert_eq!(out.can_accept_charges, None);
assert_eq!(out.unknown_reason.as_deref(), Some("processor_unreachable"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/health?test_mode=false&refresh=true"
);
}
#[tokio::test]
async fn register_airwallex_apple_pay_domains_posts_the_urls() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"environment":"live","results":[{"url":"https://shop.test","domain":"shop.test","status":"already_registered"}]}"#,
)]);
let out = client
.connectors()
.register_airwallex_apple_pay_domains(
"mer_1",
"mca_1",
&AirwallexApplePayDomainsRegisterRequest::new(["https://shop.test"]),
)
.await
.unwrap();
assert_eq!(out.results[0].status.as_deref(), Some("already_registered"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/airwallex/apple-pay-domains"
);
assert_eq!(seen[0].body_json()["urls"][0], "https://shop.test");
assert!(seen[0].body_json().get("environment").is_none());
}
const SHOPS_JSON: &str = r#"{
"merchant_connector_id": "mca_1",
"profile_id": "pro_1",
"shared_profile_ids": ["pro_2"],
"disabled_profile_ids": [],
"assigned_profile_ids": ["pro_1", "pro_2"],
"surprise_field": 1
}"#;
const CURRENCY_POLICY_JSON: &str = r#"{
"merchant_connector_id": "mca_1",
"connector_name": "stripe",
"profile_id": "pro_1",
"allowed_currencies": ["EUR", "USD"],
"unreadable": false,
"conversion": {"convert_to": "EUR", "unreadable": false},
"provider_capability": {"currencies": null, "payment_method_types": []},
"shops": [{
"profile_id": "pro_1",
"disabled": false,
"allowed_currencies": null,
"effective_currencies": ["EUR", "USD"],
"ignored_currencies": [],
"conversion": null
}],
"impact": [{
"profile_id": "pro_1",
"before": null,
"after": ["EUR", "USD"],
"removed": [],
"removed_unbounded": true,
"uncovered": []
}],
"applied": false,
"surprise_field": 1
}"#;
const WEBHOOK_ADDRESS_JSON: &str = r#"{
"connector": "stripe",
"merchant_connector_id": "mca_1",
"management": "managed",
"constraints": {
"alias_min_length": 6, "alias_max_length": 48, "prefix_max_length": 8,
"body_min_length": 12, "numeric_body_min_length": 16, "body_max_length": 32,
"max_changes": 3, "change_window_days": 30
},
"environments": [{
"environment": "live",
"shared_across_environments": false,
"mode": "anonymous",
"identifier": "wh-abc123",
"format": {"prefix": "wh-", "style": "alphanumeric", "length": 16},
"rate_limit": {"remaining_changes": 2},
"editable": true,
"groups": [],
"hidden_group_count": 0
}],
"surprise_field": 1
}"#;
const PROVIDER_ENDPOINT_JSON: &str = r#"{
"id": "we_1",
"url": "https://merchant.test/hooks/••••",
"host": "merchant.test",
"owner": "other",
"events": ["charge.succeeded"],
"enabled": true,
"created_at": 1700000000,
"fingerprint": "fp_1"
}"#;
#[tokio::test]
async fn retrieve_buyer_email_preference_sends_the_credential_set() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"merchant_connector_id":"mca_1","connector":"whop","provider_account_id":"biz_1",
"test_mode":true,"scope":"provider_account","send_customer_emails":null,
"outcome":"current","observed_at":"2026-01-01T00:00:00Z","surprise_field":1}"#,
)]);
let out = client
.connectors()
.retrieve_buyer_email_preference("mer_1", "mca/1", true)
.await
.unwrap();
assert_eq!(out.outcome, "current");
assert_eq!(out.send_customer_emails, None);
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/account/mer_1/connectors/mca%2F1/buyer-email-preference?test_mode=true"
);
}
#[tokio::test]
async fn update_buyer_email_preference_puts_the_confirmed_change() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"merchant_connector_id":"mca_1","connector":"whop","provider_account_id":"biz_1",
"test_mode":false,"scope":"provider_account","send_customer_emails":false,
"outcome":"verified","observed_at":"2026-01-01T00:00:00Z","surprise_field":1}"#,
)]);
let params = ConnectorBuyerMailUpdateRequest::new(false, "biz_1", true, false);
let out = client
.connectors()
.update_buyer_email_preference("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert_eq!(out.outcome, "verified");
assert_eq!(out.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/buyer-email-preference"
);
assert_eq!(
seen[0].body_json(),
json!({
"test_mode": false,
"expected_provider_account_id": "biz_1",
"send_customer_emails": false,
"expected_send_customer_emails": true,
"confirmed_account_wide": true
})
);
}
#[tokio::test]
async fn list_by_profile_gets_the_profile_scoped_path() {
let (client, mock) = client_with(vec![Step::ok(&format!("[{CONNECTOR_JSON}]"))]);
let out = client.connectors().list_by_profile("mer/1").await.unwrap();
assert_eq!(out[0].merchant_connector_id, "mca_1");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/account/mer%2F1/profile/connectors"
);
}
#[tokio::test]
async fn add_shops_posts_the_profile_ids() {
let (client, mock) = client_with(vec![Step::ok(SHOPS_JSON)]);
let out = client
.connectors()
.add_shops("mer_1", "mca_1", &ConnectorShopsAddRequest::new(["pro_2"]))
.await
.unwrap();
assert_eq!(out.assigned_profile_ids, ["pro_1", "pro_2"]);
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/account/mer_1/connectors/mca_1/shops"
);
assert_eq!(seen[0].body_json(), json!({"profile_ids": ["pro_2"]}));
}
#[tokio::test]
async fn consolidate_posts_the_preview_confirmation() {
let (client, mock) = client_with(vec![Step::ok(
r#"{
"merchant_connector_id": "mca_1",
"connector_name": "stripe",
"dry_run": false,
"consolidated": true,
"preview_token": "tok_1",
"accounts": [{"merchant_connector_id":"mca_1","kept":true,"eligibility":"kept","profile_ids":["pro_1"]}],
"shops": [{"profile_id":"pro_1","served_by":["mca_1"],"enabled_before":true,"enabled_after":true,"currencies_after":null}],
"conflicts": [{"setting":"label","values":[{"merchant_connector_ids":["mca_2"],"summary":{"label":"b"}}],"choosable":["mca_1","mca_2"]}],
"blockers": [],
"changes": {"routing_configs":1,"fallback_lists":0,"checkout_layouts":0,"surcharge_rules":0,
"hidden_accounts":0,"subscription_shop_configs":0,"product_references":0,
"shop_billing_settings":0,"role_grants":0,"saved_payment_methods":2,"customers":3,
"mandates":0,"subscriptions":0,"subscription_terms":0},
"surprise_field": 1
}"#,
)]);
let params = ConnectorConsolidationRequest::new(["mca_2"])
.dry_run(false)
.preview_token("tok_1")
.choice("label", "mca_1");
let out = client
.connectors()
.consolidate("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert!(out.consolidated);
assert_eq!(out.accounts[0].eligibility, "kept");
assert_eq!(out.conflicts[0].values[0].summary["label"], "b");
assert_eq!(out.changes.as_ref().unwrap().saved_payment_methods, 2);
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/account/mer_1/connectors/mca_1/consolidate"
);
assert_eq!(
seen[0].body_json(),
json!({
"merchant_connector_ids": ["mca_2"],
"dry_run": false,
"preview_token": "tok_1",
"choices": {"label": "mca_1"}
})
);
}
let mut bad = ConnectorConsolidationRequest::new(["mca_2"]);
bad.extra.insert("dry_run".to_string(), json!(true));
assert!(
client
.connectors()
.consolidate("mer_1", "mca_1", &bad)
.await
.is_err()
);
assert_eq!(mock.call_count(), 1);
}
#[tokio::test]
async fn consolidate_is_not_retried_on_a_server_error() {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(503, "{}"), Step::ok("{}")],
2,
);
let params = ConnectorConsolidationRequest::new(["mca_2"]);
assert!(
client
.connectors()
.consolidate("mer_1", "mca_1", ¶ms)
.await
.is_err()
);
assert_eq!(mock.call_count(), 1);
}
#[tokio::test]
async fn set_shop_disabled_posts_to_the_shop_path() {
let (client, mock) = client_with(vec![Step::ok(SHOPS_JSON)]);
let params = ConnectorShopUpdateRequest::new(true).reason("paused");
client
.connectors()
.set_shop_disabled("mer_1", "mca_1", "pro/2", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/shops/pro%2F2"
);
assert_eq!(
seen[0].body_json(),
json!({"disabled": true, "reason": "paused"})
);
}
#[tokio::test]
async fn remove_shop_deletes_the_shop_path() {
let (client, mock) = client_with(vec![Step::ok(SHOPS_JSON)]);
let out = client
.connectors()
.remove_shop("mer_1", "mca_1", "pro_2")
.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, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/shops/pro_2"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn currencies_gets_and_decodes_the_policy() {
let (client, mock) = client_with(vec![Step::ok(CURRENCY_POLICY_JSON)]);
let out = client
.connectors()
.currencies("mer_1", "mca_1")
.await
.unwrap();
assert_eq!(
out.allowed_currencies.as_deref(),
Some(&["EUR".to_string(), "USD".to_string()][..])
);
assert_eq!(out.conversion.convert_to.as_deref(), Some("EUR"));
assert!(out.shops[0].conversion.is_none());
assert!(out.impact.as_ref().unwrap()[0].removed_unbounded);
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/account/mer_1/connectors/mca_1/currencies"
);
}
#[tokio::test]
async fn set_currencies_sends_null_to_allow_every_currency() {
let (client, mock) = client_with(vec![Step::ok(CURRENCY_POLICY_JSON)]);
let params = ConnectorCurrencyPolicyUpdateRequest::new()
.allow_every_currency()
.conversion(ConnectorCurrencyConversionSetting::refuse())
.dry_run(true);
client
.connectors()
.set_currencies("mer_1", "mca_1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/currencies"
);
assert_eq!(
seen[0].body_json(),
json!({"allowed_currencies": null, "conversion": {"convert_to": null}, "dry_run": true})
);
}
#[tokio::test]
async fn set_shop_currencies_puts_only_the_fields_set() {
let (client, mock) = client_with(vec![Step::ok(CURRENCY_POLICY_JSON)]);
let params = ConnectorCurrencyPolicyUpdateRequest::new().allowed_currencies(["EUR"]);
client
.connectors()
.set_shop_currencies("mer_1", "mca_1", "pro_1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/mca_1/shops/pro_1/currencies"
);
assert_eq!(seen[0].body_json(), json!({"allowed_currencies": ["EUR"]}));
}
#[tokio::test]
async fn set_shop_currencies_sends_null_conversion_to_follow_the_account() {
let (client, mock) = client_with(vec![Step::ok(CURRENCY_POLICY_JSON)]);
let params = ConnectorCurrencyPolicyUpdateRequest::new()
.follow_account_currencies()
.follow_account_conversion();
client
.connectors()
.set_shop_currencies("mer_1", "mca_1", "pro_1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].body_json(),
json!({"allowed_currencies": null, "conversion": null})
);
}
#[tokio::test]
async fn verify_vault_posts_the_profile() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"passed":false,"checks":[{"id":"credentials","status":"fail","detail":"401"}],
"processors":[{"merchant_connector_id":"mca_2","connector_name":"stripe","status":"hidable"}],
"egress_ips_to_allowlist":["192.0.2.1"],"surprise_field":1}"#,
)]);
let out = client
.connectors()
.verify_vault("mer_1", "mca_1", &VaultVerifyRequest::new("pro_1"))
.await
.unwrap();
assert!(!out.passed);
assert_eq!(out.checks[0].detail.as_deref(), Some("401"));
assert_eq!(out.processors[0].status, "hidable");
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/account/mer_1/connectors/mca_1/vault/verify"
);
assert_eq!(seen[0].body_json(), json!({"profile_id": "pro_1"}));
}
#[tokio::test]
async fn vault_outages_gets_the_account_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"outages":[{"profile_id":"pro_1","profile_name":"Shop","vault_connector_id":"mca_v",
"vault_connector_name":"vgs","cause":"limit_reached","since":"2026-01-01T00:00:00Z"}],
"surprise_field":1}"#,
)]);
let out = client.connectors().vault_outages("mer/1").await.unwrap();
assert_eq!(out.outages[0].cause, "limit_reached");
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/account/mer%2F1/vault/outages"
);
}
#[tokio::test]
async fn preview_vault_routes_posts_the_profile_and_environment() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"vault_id":"tnt_1","environment":"sandbox","desired_fingerprint":"d1",
"desired_upstream_hosts":["api.stripe.com"],"current_fingerprint":null,
"changes":[{"route_id":"r1","purpose":"collect","change":"create","field_changes":[]}],
"warnings":[{"code":"no_processor","detail":"none"}],"surprise_field":1}"#,
)]);
let params = VaultRoutesPreviewRequest::new("pro_1").environment("sandbox");
let out = client
.connectors()
.preview_vault_routes("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert_eq!(out.desired_fingerprint, "d1");
assert!(out.current_fingerprint.is_none());
assert_eq!(out.changes[0].change, "create");
assert_eq!(out.warnings[0].code, "no_processor");
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/account/mer_1/connectors/mca_1/vault/routes/preview"
);
assert_eq!(
seen[0].body_json(),
json!({"profile_id": "pro_1", "environment": "sandbox"})
);
}
#[tokio::test]
async fn apply_vault_routes_sends_a_null_current_fingerprint() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"applied":true,"route_ids":{"collect":"r1","reveal":"r2"},
"collect_route_id_stored":true,"warnings":[],
"verification":{"established":["routes"],"not_established":[]},"surprise_field":1}"#,
)]);
let params = VaultRoutesApplyRequest::new("pro_1", None, "d1");
let out = client
.connectors()
.apply_vault_routes("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert!(out.applied);
assert_eq!(out.route_ids.reveal, "r2");
assert_eq!(out.verification.unwrap().established, ["routes"]);
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/account/mer_1/connectors/mca_1/vault/routes/apply"
);
assert_eq!(
seen[0].body_json(),
json!({
"profile_id": "pro_1",
"expected_current_fingerprint": null,
"expected_desired_fingerprint": "d1"
})
);
}
#[tokio::test]
async fn register_whop_apple_pay_domains_posts_the_urls() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"environment":"sandbox","results":[{"url":"https://shop.test","domain":"shop.test",
"status":"verified","whop_domain_id":"dom_1"}],"surprise_field":1}"#,
)]);
let params =
WhopApplePayDomainsRegisterRequest::new(["https://shop.test"]).environment("sandbox");
let out = client
.connectors()
.register_whop_apple_pay_domains("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert_eq!(out.results[0].status, "verified");
assert_eq!(out.results[0].whop_domain_id.as_deref(), Some("dom_1"));
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/account/mer_1/connectors/mca_1/whop/apple-pay-domains"
);
assert_eq!(
seen[0].body_json(),
json!({"urls": ["https://shop.test"], "environment": "sandbox"})
);
}
#[tokio::test]
async fn webhook_address_gets_the_address_path() {
let (client, mock) = client_with(vec![Step::ok(WEBHOOK_ADDRESS_JSON)]);
let out = client
.connectors()
.webhook_address("mer_1", "mca/1")
.await
.unwrap();
assert_eq!(out.management, "managed");
assert_eq!(out.constraints.max_changes, 3);
assert_eq!(out.environments[0].format.as_ref().unwrap().length, 16);
assert_eq!(out.environments[0].rate_limit.remaining_changes, 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/account/mer_1/connectors/webhooks/mca%2F1/address"
);
}
#[tokio::test]
async fn preview_webhook_address_posts_the_proposal() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"valid":false,"errors":[{"field":"alias","code":"too_short"}],
"identifier_final":false,"changes_address":true,
"rate_limit":{"remaining_changes":0,"next_change_allowed_at":"2026-02-01T00:00:00Z"},
"editable":true,"requires_shared_confirmation":true,
"groups":[{"credentials_sha256":"abc","contains_this_connector":true,
"current_url":"https://api.test/webhooks/x","accounts":[],"hidden_account_count":0}],
"hidden_group_count":1,"surprise_field":1}"#,
)]);
let params = WebhookAddressRequest::new("anonymous")
.environment("live")
.format(WebhookAddressFormat::new("wh-", "alphanumeric", 16));
let out = client
.connectors()
.preview_webhook_address("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert!(!out.valid);
assert_eq!(out.errors[0].code, "too_short");
assert!(out.groups[0].contains_this_connector);
assert_eq!(out.hidden_group_count, 1);
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/account/mer_1/connectors/webhooks/mca_1/address/preview"
);
assert_eq!(
seen[0].body_json(),
json!({
"environment": "live",
"mode": "anonymous",
"format": {"prefix": "wh-", "style": "alphanumeric", "length": 16}
})
);
}
#[tokio::test]
async fn update_webhook_address_puts_the_confirmed_address() {
let (client, mock) = client_with(vec![Step::ok(WEBHOOK_ADDRESS_JSON)]);
let params = WebhookAddressRequest::new("custom")
.environment("live")
.alias("my-shop")
.confirm_shared(true);
client
.connectors()
.update_webhook_address("mer_1", "mca_1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/webhooks/mca_1/address"
);
assert_eq!(
seen[0].body_json(),
json!({"environment": "live", "mode": "custom", "alias": "my-shop", "confirm_shared": true})
);
}
#[tokio::test]
async fn list_provider_webhooks_sends_the_environment() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"connector":"stripe","environment":"sandbox","coverage":"account",
"capabilities":{{"create":true,"update_url":true,"update_events":true,
"update_enabled":true,"delete":true,"replace_all":false}},
"endpoint_limit":16,"required_events":["charge.succeeded"],
"managed":{{"status":"registered","missing_events":[]}},
"endpoints":[{PROVIDER_ENDPOINT_JSON}],"editable":true,
"read_at":"2026-01-01T00:00:00Z","surprise_field":1}}"#
))]);
let out = client
.connectors()
.list_provider_webhooks("mer_1", "mca_1", "sandbox")
.await
.unwrap();
assert_eq!(out.endpoint_limit, Some(16));
assert!(!out.capabilities.replace_all);
assert_eq!(out.managed.status, "registered");
assert_eq!(out.endpoints[0].created_at, Some(1_700_000_000));
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/account/mer_1/connectors/webhooks/mca_1/provider?environment=sandbox"
);
}
#[tokio::test]
async fn create_provider_webhook_posts_and_keeps_the_secret_out_of_debug() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"endpoint":{PROVIDER_ENDPOINT_JSON},"signing_secret":"whsec_topsecret","surprise_field":1}}"#
))]);
let params = ProviderWebhookCreateRequest::new(
"live",
"https://merchant.test/hooks/tok_secret",
["charge.succeeded"],
);
let out = client
.connectors()
.create_provider_webhook("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert_eq!(out.signing_secret.as_deref(), Some("whsec_topsecret"));
assert_eq!(out.endpoint.fingerprint, "fp_1");
assert_eq!(out.extra["surprise_field"], 1);
assert!(!format!("{out:?}").contains("whsec_topsecret"));
assert!(!format!("{params:?}").contains("tok_secret"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/webhooks/mca_1/provider"
);
assert_eq!(
seen[0].body_json(),
json!({
"environment": "live",
"url": "https://merchant.test/hooks/tok_secret",
"events": ["charge.succeeded"]
})
);
}
#[tokio::test]
async fn update_provider_webhook_patches_the_encoded_webhook_path() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"surprise_field":1,{}"#,
&PROVIDER_ENDPOINT_JSON.trim_start()[1..]
))]);
let params = ProviderWebhookUpdateRequest::new("live", "fp_1")
.url("https://merchant.test/hooks/tok_secret")
.events(["charge.refunded"])
.enabled(false);
let out = client
.connectors()
.update_provider_webhook("mer_1", "mca_1", "we/1", ¶ms)
.await
.unwrap();
assert_eq!(out.id, "we_1");
assert_eq!(out.extra["surprise_field"], 1);
assert!(!format!("{params:?}").contains("tok_secret"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PATCH");
assert_eq!(
seen[0].url,
"https://api.test/account/mer_1/connectors/webhooks/mca_1/provider/we%2F1"
);
assert_eq!(
seen[0].body_json(),
json!({
"environment": "live",
"fingerprint": "fp_1",
"url": "https://merchant.test/hooks/tok_secret",
"events": ["charge.refunded"],
"enabled": false
})
);
}
#[tokio::test]
async fn delete_provider_webhook_posts_to_the_delete_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"id":"we_1","url":"https://merchant.test/••••","outcome":"deleted",
"surprise_field":1}"#,
)]);
let params = ProviderWebhookDeleteRequest::new("sandbox", "fp_1").confirm_managed(true);
let out = client
.connectors()
.delete_provider_webhook("mer_1", "mca_1", "we_1", ¶ms)
.await
.unwrap();
assert_eq!(out.outcome, "deleted");
assert_eq!(out.error_message, None);
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/account/mer_1/connectors/webhooks/mca_1/provider/we_1/delete"
);
assert_eq!(
seen[0].body_json(),
json!({"environment": "sandbox", "fingerprint": "fp_1", "confirm_managed": true})
);
assert!(!seen[0].had_idempotency_key());
}
#[tokio::test]
async fn preview_provider_webhook_replace_sends_the_environment() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"connector":"stripe","environment":"live","coverage":"account",
"sequence":"register_first","managed":{{"status":"registered"}},
"delete":[{PROVIDER_ENDPOINT_JSON}],"keep":[],"accounts":[],
"hidden_account_count":0,"editable":true,"surprise_field":1}}"#
))]);
let out = client
.connectors()
.preview_provider_webhook_replace("mer_1", "mca_1", "live")
.await
.unwrap();
assert_eq!(out.sequence, "register_first");
assert_eq!(out.delete[0].fingerprint, "fp_1");
assert!(out.keep.is_empty());
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/account/mer_1/connectors/webhooks/mca_1/provider/replace?environment=live"
);
}
#[tokio::test]
async fn replace_provider_webhooks_posts_the_confirmations() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"status":"completed","sequence":"delete_first",
"managed":{"status":"registered"},
"results":[{"id":"we_1","url":"https://merchant.test/••••","outcome":"deleted"}],
"remaining":[],"unconfirmed":[],"surprise_field":1}"#,
)]);
let params = ProviderWebhookReplaceRequest::new(
"live",
vec![ProviderWebhookConfirmation::new("we_1", "fp_1")],
)
.accept_delete_first(true);
let out = client
.connectors()
.replace_provider_webhooks("mer_1", "mca_1", ¶ms)
.await
.unwrap();
assert_eq!(out.status, "completed");
assert_eq!(out.results[0].outcome, "deleted");
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/account/mer_1/connectors/webhooks/mca_1/provider/replace"
);
assert_eq!(
seen[0].body_json(),
json!({
"environment": "live",
"confirmed": [{"id": "we_1", "fingerprint": "fp_1"}],
"accept_delete_first": true
})
);
}
#[tokio::test]
async fn replace_provider_webhooks_is_not_retried_on_a_server_error() {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(503, "{}"), Step::status(503, "{}")],
2,
);
let params = ProviderWebhookReplaceRequest::new("live", vec![]);
assert!(
client
.connectors()
.replace_provider_webhooks("mer_1", "mca_1", ¶ms)
.await
.is_err()
);
assert_eq!(mock.call_count(), 1);
}
fn assert_named_covers(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}`"
);
}
}
#[test]
fn connector_consolidation_request_named_fields_are_complete() {
let req = ConnectorConsolidationRequest::new(["mca_2"])
.dry_run(true)
.preview_token("tok")
.choice("label", "mca_1");
assert_named_covers(
serde_json::to_value(req).unwrap(),
CONNECTOR_CONSOLIDATION_REQUEST_NAMED,
"CONNECTOR_CONSOLIDATION_REQUEST_NAMED",
);
}
#[test]
fn connector_shop_update_request_named_fields_are_complete() {
let req = ConnectorShopUpdateRequest::new(true).reason("r");
assert_named_covers(
serde_json::to_value(req).unwrap(),
CONNECTOR_SHOP_UPDATE_REQUEST_NAMED,
"CONNECTOR_SHOP_UPDATE_REQUEST_NAMED",
);
}
#[test]
fn connector_currency_policy_update_request_named_fields_are_complete() {
let req = ConnectorCurrencyPolicyUpdateRequest::new()
.allowed_currencies(["EUR"])
.conversion(ConnectorCurrencyConversionSetting::convert_to("EUR"))
.dry_run(true);
assert_named_covers(
serde_json::to_value(req).unwrap(),
CONNECTOR_CURRENCY_POLICY_UPDATE_REQUEST_NAMED,
"CONNECTOR_CURRENCY_POLICY_UPDATE_REQUEST_NAMED",
);
}
#[test]
fn vault_routes_preview_request_named_fields_are_complete() {
let req = VaultRoutesPreviewRequest::new("pro_1").environment("live");
assert_named_covers(
serde_json::to_value(req).unwrap(),
VAULT_ROUTES_PREVIEW_REQUEST_NAMED,
"VAULT_ROUTES_PREVIEW_REQUEST_NAMED",
);
}
#[test]
fn vault_routes_apply_request_named_fields_are_complete() {
let req =
VaultRoutesApplyRequest::new("pro_1", Some("c1".to_string()), "d1").environment("live");
assert_named_covers(
serde_json::to_value(req).unwrap(),
VAULT_ROUTES_APPLY_REQUEST_NAMED,
"VAULT_ROUTES_APPLY_REQUEST_NAMED",
);
}
#[test]
fn webhook_address_request_named_fields_are_complete() {
let req = WebhookAddressRequest::new("anonymous")
.environment("live")
.alias("my-shop")
.format(WebhookAddressFormat::new("wh-", "alphanumeric", 16))
.regenerate(true)
.confirm_shared(true);
assert_named_covers(
serde_json::to_value(req).unwrap(),
WEBHOOK_ADDRESS_REQUEST_NAMED,
"WEBHOOK_ADDRESS_REQUEST_NAMED",
);
}
#[test]
fn new_request_validators_reject_colliding_extra_keys() {
fn expect_collision(result: Result<()>, key: &str) {
match result.unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains(key), "{msg}"),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
let mut a = ConnectorConsolidationRequest::new(["mca_2"]);
a.extra.insert("choices".to_string(), json!({}));
expect_collision(a.validate(), "choices");
let mut b = ConnectorShopUpdateRequest::new(true);
b.extra.insert("disabled".to_string(), json!(false));
expect_collision(b.validate(), "disabled");
let mut c = ConnectorCurrencyPolicyUpdateRequest::new();
c.extra.insert("conversion".to_string(), json!(null));
expect_collision(c.validate(), "conversion");
let mut d = VaultRoutesPreviewRequest::new("pro_1");
d.extra.insert("profile_id".to_string(), json!("x"));
expect_collision(d.validate(), "profile_id");
let mut e = VaultRoutesApplyRequest::new("pro_1", None, "d1");
e.extra
.insert("expected_desired_fingerprint".to_string(), json!("x"));
expect_collision(e.validate(), "expected_desired_fingerprint");
let mut f = WebhookAddressRequest::new("standard");
f.extra.insert("mode".to_string(), json!("custom"));
expect_collision(f.validate(), "mode");
}
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 = VaultVerifyRequest::new("pro_1");
assert!(
client
.connectors()
.verify_vault("mer_1", "mca_1", ¶ms)
.await
.is_err()
);
assert_sent_once_unkeyed(&mock);
let (client, mock) = keyed_client_over_503s();
let params = ProviderWebhookReplaceRequest::new("live", vec![]);
assert!(
client
.connectors()
.replace_provider_webhooks("mer_1", "mca_1", ¶ms)
.await
.is_err()
);
assert_sent_once_unkeyed(&mock);
}
}