use std::sync::Arc;
use serde::Serialize;
use serde::de::IgnoredAny;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::buyer_case::{
BuyerCaseList, BuyerEvidence, BuyerEvidenceEntry, BuyerEvidenceFile,
};
use crate::core::models::buyer_conversation::{
BuyerConversationAttachment, BuyerPortalConversationList, BuyerPortalMessage,
BuyerPortalMessagePage,
};
use crate::core::models::buyer_portal::{
BuyerPortalContactEmailOutcome, BuyerPortalInvoice, BuyerPortalInvoicePage,
BuyerPortalPlanPage, BuyerPortalProfile, BuyerPortalPurchasePage, BuyerPortalRefundRequest,
BuyerPortalSession, BuyerPortalSubscription, BuyerPortalSubscriptionPage,
NativeEnrollmentAbandonResponse, NativeEnrollmentResponse,
};
use crate::core::models::common::AddressDetails;
use crate::http::client::Inner;
use crate::http::multipart::{FilePart, Multipart, encode_file_with_fields};
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct BuyerPortal {
inner: Arc<Inner>,
}
impl BuyerPortal {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn get_session(&self) -> Result<BuyerPortalSession> {
self.get("/buyer-portal/session", &[]).await
}
pub async fn list_cases(&self) -> Result<BuyerCaseList> {
self.get("/buyer-portal/cases", &[]).await
}
pub async fn case_evidence(&self, case_id: &str) -> Result<BuyerEvidence> {
self.get(&evidence_path(case_id), &[]).await
}
pub async fn upload_evidence_file(
&self,
case_id: &str,
upload: &BuyerFileUpload<'_>,
) -> Result<BuyerEvidenceFile> {
let path = format!("{}/files", evidence_path(case_id));
let form = upload.encode();
self.inner
.request_with_content_type_and_query(
HttpMethod::Post,
&path,
&[],
&form.body,
&form.content_type,
)
.await
}
pub async fn download_evidence_file(&self, case_id: &str, file_id: &str) -> Result<Vec<u8>> {
let path = format!(
"{}/files/{}",
evidence_path(case_id),
encode_segment(file_id)
);
self.inner
.request_bytes(HttpMethod::Get, &path, &[], ANY_FILE)
.await
}
pub async fn remove_evidence_file(&self, case_id: &str, file_id: &str) -> Result<()> {
let path = format!(
"{}/files/{}",
evidence_path(case_id),
encode_segment(file_id)
);
delete_ignoring_body(&self.inner, &path, &[]).await
}
pub async fn submit_evidence(
&self,
case_id: &str,
params: &BuyerEvidenceSubmitRequest,
) -> Result<BuyerEvidenceEntry> {
params.validate()?;
let path = format!("{}/submissions", evidence_path(case_id));
self.post(&path, params, &[]).await
}
pub async fn request_evidence_extension(
&self,
case_id: &str,
params: &BuyerEvidenceExtensionRequest,
) -> Result<BuyerEvidenceEntry> {
let path = format!("{}/extension-requests", evidence_path(case_id));
self.post(&path, params, &[]).await
}
pub async fn list_conversations(&self) -> Result<BuyerPortalConversationList> {
self.get("/buyer-portal/conversations", &[]).await
}
pub async fn list_messages(
&self,
params: Option<&BuyerConversationParams>,
) -> Result<BuyerPortalMessagePage> {
let query = params.map(BuyerConversationParams::to_query);
self.get("/buyer-portal/messages", query.as_deref().unwrap_or(&[]))
.await
}
pub async fn send_message(
&self,
params: &BuyerMessageCreateRequest,
) -> Result<BuyerPortalMessage> {
params.validate()?;
self.post("/buyer-portal/messages", params, &[]).await
}
pub async fn mark_messages_read(
&self,
params: Option<&BuyerConversationParams>,
) -> Result<BuyerPortalConversationList> {
let query = params.map(BuyerConversationParams::to_query);
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/buyer-portal/messages/read",
None,
query.as_deref().unwrap_or(&[]),
None,
)
.await
}
pub async fn upload_message_file(
&self,
upload: &BuyerFileUpload<'_>,
params: Option<&BuyerAttachmentParams>,
) -> Result<BuyerConversationAttachment> {
let query = params.map(BuyerAttachmentParams::to_query);
let form = upload.encode();
self.inner
.request_with_content_type_and_query(
HttpMethod::Post,
"/buyer-portal/messages/files",
query.as_deref().unwrap_or(&[]),
&form.body,
&form.content_type,
)
.await
}
pub async fn download_message_file(
&self,
file_id: &str,
params: Option<&BuyerAttachmentParams>,
) -> Result<Vec<u8>> {
let path = format!("/buyer-portal/messages/files/{}", encode_segment(file_id));
let query = params.map(BuyerAttachmentParams::to_query);
self.inner
.request_bytes(
HttpMethod::Get,
&path,
query.as_deref().unwrap_or(&[]),
ANY_FILE,
)
.await
}
pub async fn remove_message_file(
&self,
file_id: &str,
params: Option<&BuyerAttachmentParams>,
) -> Result<()> {
let path = format!("/buyer-portal/messages/files/{}", encode_segment(file_id));
let query = params.map(BuyerAttachmentParams::to_query);
delete_ignoring_body(&self.inner, &path, query.as_deref().unwrap_or(&[])).await
}
pub async fn get_profile(&self) -> Result<BuyerPortalProfile> {
self.get("/buyer-portal/profile", &[]).await
}
pub async fn update_profile(
&self,
params: &BuyerPortalProfileUpdateRequest,
) -> Result<BuyerPortalProfile> {
params.validate()?;
self.post("/buyer-portal/profile", params, &[]).await
}
pub async fn change_contact_email(
&self,
command: &BuyerPortalContactEmailCommand,
) -> Result<BuyerPortalContactEmailOutcome> {
self.post("/buyer-portal/profile/contact-email", command, &[])
.await
}
pub async fn create_refund_request(
&self,
purchase_id: &str,
params: &BuyerPortalRefundRequestCreateRequest,
) -> Result<BuyerPortalRefundRequest> {
params.validate()?;
let path = format!(
"/buyer-portal/purchases/{}/refund-requests",
encode_segment(purchase_id)
);
self.post(&path, params, &[]).await
}
pub async fn list_invoices(
&self,
params: Option<&BuyerPortalPageParams>,
) -> Result<BuyerPortalInvoicePage> {
let query = params.map(BuyerPortalPageParams::to_query);
self.get("/buyer-portal/invoices", query.as_deref().unwrap_or(&[]))
.await
}
pub async fn retrieve_invoice(&self, invoice_id: &str) -> Result<BuyerPortalInvoice> {
self.get(&invoice_path(invoice_id), &[]).await
}
pub async fn download_invoice_pdf(&self, invoice_id: &str) -> Result<Vec<u8>> {
let path = format!("{}/pdf", invoice_path(invoice_id));
self.inner
.request_bytes(HttpMethod::Get, &path, &[], "application/pdf")
.await
}
pub async fn list_purchases(
&self,
params: Option<&BuyerPortalPageParams>,
) -> Result<BuyerPortalPurchasePage> {
let query = params.map(BuyerPortalPageParams::to_query);
self.get("/buyer-portal/purchases", query.as_deref().unwrap_or(&[]))
.await
}
pub async fn list_subscriptions(
&self,
params: Option<&BuyerPortalPageParams>,
) -> Result<BuyerPortalSubscriptionPage> {
let query = params.map(BuyerPortalPageParams::to_query);
self.get(
"/buyer-portal/subscriptions",
query.as_deref().unwrap_or(&[]),
)
.await
}
pub async fn act_on_subscription(
&self,
subscription_id: &str,
params: &BuyerPortalSubscriptionActionRequest,
) -> Result<BuyerPortalSubscription> {
let path = format!("{}/actions", subscription_path(subscription_id));
self.post(&path, params, &[]).await
}
pub async fn list_subscription_plans(
&self,
subscription_id: &str,
params: Option<&BuyerPortalPageParams>,
) -> Result<BuyerPortalPlanPage> {
let path = format!("{}/plans", subscription_path(subscription_id));
let query = params.map(BuyerPortalPageParams::to_query);
self.get(&path, query.as_deref().unwrap_or(&[])).await
}
pub async fn change_subscription_plan(
&self,
subscription_id: &str,
params: &BuyerPortalPlanChangeRequest,
) -> Result<BuyerPortalSubscription> {
params.validate()?;
let path = format!("{}/change-plan", subscription_path(subscription_id));
self.post(&path, params, &[]).await
}
pub async fn list_native_plans(
&self,
profile_id: &str,
params: Option<&BuyerPortalPageParams>,
) -> Result<BuyerPortalPlanPage> {
let path = format!(
"/buyer-portal/subscriptions/native/plans/{}",
encode_segment(profile_id)
);
let query = params.map(BuyerPortalPageParams::to_query);
self.get(&path, query.as_deref().unwrap_or(&[])).await
}
pub async fn enroll_native(
&self,
params: &NativeEnrollmentRequest,
) -> Result<NativeEnrollmentResponse> {
params.validate()?;
self.post("/buyer-portal/subscriptions/native/enroll", params, &[])
.await
}
pub async fn get_native_enrollment(
&self,
subscription_id: &str,
profile_id: &str,
) -> Result<NativeEnrollmentResponse> {
self.get(
&enrollment_path(subscription_id),
&[("profile_id", profile_id.to_string())],
)
.await
}
pub async fn abandon_native_enrollment(
&self,
subscription_id: &str,
profile_id: &str,
) -> Result<NativeEnrollmentAbandonResponse> {
let path = format!("{}/abandon", enrollment_path(subscription_id));
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
&path,
None,
&[("profile_id", profile_id.to_string())],
None,
)
.await
}
async fn get<T: serde::de::DeserializeOwned>(
&self,
path: &str,
query: &[(&str, String)],
) -> Result<T> {
self.inner
.request(HttpMethod::Get, path, None, query, None)
.await
}
async fn post<B: Serialize, T: serde::de::DeserializeOwned>(
&self,
path: &str,
body: &B,
query: &[(&str, String)],
) -> Result<T> {
let body = to_json_vec(body)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, path, Some(&body), query, None)
.await
}
}
pub(crate) const ANY_FILE: &str = "*/*";
pub(crate) async fn delete_ignoring_body(
inner: &Inner,
path: &str,
query: &[(&str, String)],
) -> Result<()> {
inner
.request_body_keyed_with_query::<IgnoredAny>(HttpMethod::Delete, path, None, query, None)
.await
.map(|_| ())
}
fn evidence_path(case_id: &str) -> String {
format!("/buyer-portal/cases/{}/evidence", encode_segment(case_id))
}
fn invoice_path(invoice_id: &str) -> String {
format!("/buyer-portal/invoices/{}", encode_segment(invoice_id))
}
fn subscription_path(subscription_id: &str) -> String {
format!(
"/buyer-portal/subscriptions/{}",
encode_segment(subscription_id)
)
}
fn enrollment_path(subscription_id: &str) -> String {
format!(
"/buyer-portal/subscriptions/native/enroll/{}",
encode_segment(subscription_id)
)
}
pub(crate) fn check_extra(
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(Clone, Copy)]
pub struct BuyerFileUpload<'a> {
pub client_upload_id: &'a str,
pub file_name: &'a str,
pub content_type: &'a str,
pub bytes: &'a [u8],
}
impl<'a> BuyerFileUpload<'a> {
pub fn new(
client_upload_id: &'a str,
file_name: &'a str,
content_type: &'a str,
bytes: &'a [u8],
) -> Self {
Self {
client_upload_id,
file_name,
content_type,
bytes,
}
}
pub(crate) fn encode(&self) -> Multipart {
encode_file_with_fields(
&[("client_upload_id", self.client_upload_id)],
&FilePart {
field: "file",
file_name: self.file_name,
content_type: self.content_type,
bytes: self.bytes,
},
)
}
}
impl std::fmt::Debug for BuyerFileUpload<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BuyerFileUpload")
.field("client_upload_id", &self.client_upload_id)
.field("content_type", &self.content_type)
.field("len", &self.bytes.len())
.finish_non_exhaustive()
}
}
#[derive(Debug, Clone, Default)]
pub struct BuyerConversationParams {
pub shop: Option<String>,
pub test_mode: Option<bool>,
pub before: Option<String>,
pub limit: Option<i32>,
}
impl BuyerConversationParams {
pub fn new(shop: impl Into<String>) -> Self {
Self {
shop: Some(shop.into()),
..Default::default()
}
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = Some(test_mode);
self
}
#[must_use]
pub fn before(mut self, before: impl Into<String>) -> Self {
self.before = Some(before.into());
self
}
#[must_use]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
pub(crate) fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.shop {
q.push(("shop", v.clone()));
}
if let Some(v) = self.test_mode {
q.push(("test_mode", v.to_string()));
}
if let Some(v) = &self.before {
q.push(("before", v.clone()));
}
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct BuyerAttachmentParams {
pub shop: Option<String>,
pub test_mode: Option<bool>,
}
impl BuyerAttachmentParams {
pub fn new(shop: impl Into<String>) -> Self {
Self {
shop: Some(shop.into()),
test_mode: None,
}
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = Some(test_mode);
self
}
pub(crate) fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.shop {
q.push(("shop", v.clone()));
}
if let Some(v) = self.test_mode {
q.push(("test_mode", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct BuyerPortalPageParams {
pub limit: Option<i64>,
pub offset: Option<i64>,
}
impl BuyerPortalPageParams {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn limit(mut self, limit: i64) -> Self {
self.limit = Some(limit);
self
}
#[must_use]
pub fn offset(mut self, offset: i64) -> Self {
self.offset = Some(offset);
self
}
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.offset {
q.push(("offset", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct BuyerEvidenceSubmitRequest {
pub client_submission_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub explanation: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub files: Vec<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl BuyerEvidenceSubmitRequest {
pub fn new(client_submission_id: impl Into<String>) -> Self {
Self {
client_submission_id: client_submission_id.into(),
..Default::default()
}
}
#[must_use]
pub fn explanation(mut self, explanation: impl Into<String>) -> Self {
self.explanation = Some(explanation.into());
self
}
#[must_use]
pub fn files(mut self, files: Vec<String>) -> Self {
self.files = files;
self
}
}
const BUYER_EVIDENCE_SUBMIT_REQUEST_NAMED: &[&str] =
&["client_submission_id", "explanation", "files"];
impl ValidateRequest for BuyerEvidenceSubmitRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
BUYER_EVIDENCE_SUBMIT_REQUEST_NAMED,
"BuyerEvidenceSubmitRequest",
)
}
}
#[derive(Debug, Clone, Serialize)]
pub struct BuyerEvidenceExtensionRequest {
pub message: String,
}
impl BuyerEvidenceExtensionRequest {
pub fn new(message: impl Into<String>) -> Self {
Self {
message: message.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct BuyerMessageCreateRequest {
pub client_message_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub shop: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub test_mode: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub body: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub purchase: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub attachments: Vec<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl BuyerMessageCreateRequest {
pub fn new(client_message_id: impl Into<String>) -> Self {
Self {
client_message_id: client_message_id.into(),
..Default::default()
}
}
#[must_use]
pub fn shop(mut self, shop: impl Into<String>) -> Self {
self.shop = Some(shop.into());
self
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = Some(test_mode);
self
}
#[must_use]
pub fn body(mut self, body: impl Into<String>) -> Self {
self.body = Some(body.into());
self
}
#[must_use]
pub fn purchase(mut self, purchase: impl Into<String>) -> Self {
self.purchase = Some(purchase.into());
self
}
#[must_use]
pub fn attachments(mut self, attachments: Vec<String>) -> Self {
self.attachments = attachments;
self
}
}
const BUYER_MESSAGE_CREATE_REQUEST_NAMED: &[&str] = &[
"client_message_id",
"shop",
"test_mode",
"body",
"purchase",
"attachments",
];
impl ValidateRequest for BuyerMessageCreateRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
BUYER_MESSAGE_CREATE_REQUEST_NAMED,
"BuyerMessageCreateRequest",
)
}
}
#[derive(Clone, Default, Serialize)]
pub struct BuyerPortalProfileUpdateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_country_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_registration_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<AddressDetails>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl BuyerPortalProfileUpdateRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
#[must_use]
pub fn phone(mut self, country_code: impl Into<String>, phone: impl Into<String>) -> Self {
self.phone_country_code = Some(country_code.into());
self.phone = Some(phone.into());
self
}
#[must_use]
pub fn tax_registration_id(mut self, tax_registration_id: impl Into<String>) -> Self {
self.tax_registration_id = Some(tax_registration_id.into());
self
}
#[must_use]
pub fn address(mut self, address: AddressDetails) -> Self {
self.address = Some(address);
self
}
}
impl std::fmt::Debug for BuyerPortalProfileUpdateRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let set = |present: bool| if present { "<redacted>" } else { "<unset>" };
f.debug_struct("BuyerPortalProfileUpdateRequest")
.field("name", &set(self.name.is_some()))
.field("phone", &set(self.phone.is_some()))
.field("phone_country_code", &self.phone_country_code)
.field(
"tax_registration_id",
&set(self.tax_registration_id.is_some()),
)
.field("address", &set(self.address.is_some()))
.field("extra_keys", &self.extra.keys().collect::<Vec<_>>())
.finish()
}
}
const BUYER_PORTAL_PROFILE_UPDATE_REQUEST_NAMED: &[&str] = &[
"name",
"phone",
"phone_country_code",
"tax_registration_id",
"address",
];
impl ValidateRequest for BuyerPortalProfileUpdateRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
BUYER_PORTAL_PROFILE_UPDATE_REQUEST_NAMED,
"BuyerPortalProfileUpdateRequest",
)
}
}
#[derive(Clone, Serialize)]
#[serde(tag = "action", rename_all = "snake_case")]
#[non_exhaustive]
pub enum BuyerPortalContactEmailCommand {
Request {
operation_id: String,
email: String,
},
Confirm {
operation_id: String,
proof: String,
},
}
impl BuyerPortalContactEmailCommand {
pub fn request(operation_id: impl Into<String>, email: impl Into<String>) -> Self {
Self::Request {
operation_id: operation_id.into(),
email: email.into(),
}
}
pub fn confirm(operation_id: impl Into<String>, proof: impl Into<String>) -> Self {
Self::Confirm {
operation_id: operation_id.into(),
proof: proof.into(),
}
}
}
impl std::fmt::Debug for BuyerPortalContactEmailCommand {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Request { operation_id, .. } => f
.debug_struct("Request")
.field("operation_id", operation_id)
.field("email", &"<redacted>")
.finish(),
Self::Confirm { operation_id, .. } => f
.debug_struct("Confirm")
.field("operation_id", operation_id)
.field("proof", &"<redacted>")
.finish(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct BuyerPortalRefundRequestCreateRequest {
pub reason: String,
pub message: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl BuyerPortalRefundRequestCreateRequest {
pub fn new(reason: impl Into<String>, message: impl Into<String>) -> Self {
Self {
reason: reason.into(),
message: message.into(),
..Default::default()
}
}
#[must_use]
pub fn amount(mut self, amount: i64) -> Self {
self.amount = Some(amount);
self
}
}
const BUYER_PORTAL_REFUND_REQUEST_CREATE_REQUEST_NAMED: &[&str] = &["reason", "message", "amount"];
impl ValidateRequest for BuyerPortalRefundRequestCreateRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
BUYER_PORTAL_REFUND_REQUEST_CREATE_REQUEST_NAMED,
"BuyerPortalRefundRequestCreateRequest",
)
}
}
#[derive(Debug, Clone, Serialize)]
pub struct BuyerPortalSubscriptionActionRequest {
pub action: String,
}
impl BuyerPortalSubscriptionActionRequest {
pub fn new(action: impl Into<String>) -> Self {
Self {
action: action.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct BuyerPortalPlanChangeRequest {
pub product_id: String,
pub price_id: String,
pub confirmed_amount: i64,
pub confirmed_currency: String,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl BuyerPortalPlanChangeRequest {
pub fn new(
product_id: impl Into<String>,
price_id: impl Into<String>,
confirmed_amount: i64,
confirmed_currency: impl Into<String>,
) -> Self {
Self {
product_id: product_id.into(),
price_id: price_id.into(),
confirmed_amount,
confirmed_currency: confirmed_currency.into(),
extra: serde_json::Map::new(),
}
}
}
const BUYER_PORTAL_PLAN_CHANGE_REQUEST_NAMED: &[&str] = &[
"product_id",
"price_id",
"confirmed_amount",
"confirmed_currency",
];
impl ValidateRequest for BuyerPortalPlanChangeRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
BUYER_PORTAL_PLAN_CHANGE_REQUEST_NAMED,
"BuyerPortalPlanChangeRequest",
)
}
}
#[derive(Clone, Serialize)]
pub struct NativeEnrollmentRequest {
pub subscription_id: String,
pub profile_id: String,
pub product_id: String,
pub price_id: String,
pub disclosed_amount: i64,
pub disclosed_currency: String,
pub disclosed_interval: String,
pub disclosed_interval_count: i32,
pub recurring_terms_accepted: bool,
pub payment_details: Value,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl NativeEnrollmentRequest {
pub fn new(
subscription_id: impl Into<String>,
profile_id: impl Into<String>,
product_id: impl Into<String>,
price_id: impl Into<String>,
) -> Self {
Self {
subscription_id: subscription_id.into(),
profile_id: profile_id.into(),
product_id: product_id.into(),
price_id: price_id.into(),
disclosed_amount: 0,
disclosed_currency: String::new(),
disclosed_interval: String::new(),
disclosed_interval_count: 1,
recurring_terms_accepted: false,
payment_details: Value::Object(serde_json::Map::new()),
extra: serde_json::Map::new(),
}
}
#[must_use]
pub fn disclosed(
mut self,
amount: i64,
currency: impl Into<String>,
interval: impl Into<String>,
interval_count: i32,
) -> Self {
self.disclosed_amount = amount;
self.disclosed_currency = currency.into();
self.disclosed_interval = interval.into();
self.disclosed_interval_count = interval_count;
self
}
#[must_use]
pub fn recurring_terms_accepted(mut self, accepted: bool) -> Self {
self.recurring_terms_accepted = accepted;
self
}
#[must_use]
pub fn payment_details(mut self, payment_details: Value) -> Self {
self.payment_details = payment_details;
self
}
}
impl std::fmt::Debug for NativeEnrollmentRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("NativeEnrollmentRequest")
.field("subscription_id", &self.subscription_id)
.field("profile_id", &self.profile_id)
.field("product_id", &self.product_id)
.field("price_id", &self.price_id)
.field("disclosed_amount", &self.disclosed_amount)
.field("disclosed_currency", &self.disclosed_currency)
.field("disclosed_interval", &self.disclosed_interval)
.field("disclosed_interval_count", &self.disclosed_interval_count)
.field("recurring_terms_accepted", &self.recurring_terms_accepted)
.field("payment_details", &"<redacted>")
.finish_non_exhaustive()
}
}
const NATIVE_ENROLLMENT_REQUEST_NAMED: &[&str] = &[
"subscription_id",
"profile_id",
"product_id",
"price_id",
"disclosed_amount",
"disclosed_currency",
"disclosed_interval",
"disclosed_interval_count",
"recurring_terms_accepted",
"payment_details",
];
impl ValidateRequest for NativeEnrollmentRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
NATIVE_ENROLLMENT_REQUEST_NAMED,
"NativeEnrollmentRequest",
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with, client_with_retries};
use serde_json::json;
const CASE_LIST_JSON: &str = r#"{
"data": [{
"id": "case_1", "kind": "refund_request", "category": "refund_request",
"origin": "buyer_portal", "state": "waiting_for_merchant",
"next_actor": "merchant", "outcome": "pending", "shop_name": "Shop",
"amount": 1200, "currency": "EUR",
"created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z",
"events": [{"at": "2026-01-01T00:00:00Z", "kind": "opened", "actor": "buyer"}],
"history_complete": true, "case_surprise": 1
}],
"has_more": false, "unconfirmed_records": false, "surprise_field": 1
}"#;
const EVIDENCE_JSON: &str = r#"{
"available": true, "state": "awaiting_buyer",
"rules": {"file_types": ["pdf"], "max_files": 5, "max_file_bytes": 10485760,
"explanation_required": false, "explanation_max_chars": 4000},
"deadline": {"due_at": "2026-02-01T00:00:00Z", "kind": "initial", "passed": false},
"can_submit": true, "can_request_extension": true, "extension_requested": false,
"saved_files": [], "history": [], "surprise_field": "x"
}"#;
const EVIDENCE_FILE_JSON: &str = r#"{
"id": "file_1", "file_name": "receipt.pdf", "file_type": "pdf",
"size_bytes": 4, "uploaded_at": "2026-01-01T00:00:00Z", "submitted": false,
"surprise_field": true
}"#;
const EVIDENCE_ENTRY_JSON: &str = r#"{
"id": "ent_1", "kind": "submitted", "actor": "buyer", "at": "2026-01-01T00:00:00Z",
"body": "It never arrived", "files": [], "surprise_field": 2
}"#;
const CONVERSATION_LIST_JSON: &str = r#"{
"data": [{
"id": "conv_1", "shop": "pro_1", "shop_name": "Shop", "test_mode": false,
"status": "open", "last_message_at": "2026-01-01T00:00:00Z",
"last_message_by": "merchant", "unread": true
}],
"unconfirmed_records": false, "surprise_field": 3
}"#;
const MESSAGE_PAGE_JSON: &str = r#"{
"conversation": null, "messages": [], "has_more": false, "case_updates": [],
"attachment_rules": {"enabled": true, "file_types": ["pdf", "png"],
"max_file_megabytes": 10, "max_files": 5},
"surprise_field": 4
}"#;
const MESSAGE_JSON: &str = r#"{
"id": "msg_1", "sender": "buyer", "body": "Hello", "attachments": [],
"created_at": "2026-01-01T00:00:00Z", "surprise_field": 5
}"#;
const ATTACHMENT_JSON: &str = r#"{
"id": "att_1", "file_name": "photo.png", "file_type": "png", "size_bytes": 4,
"surprise_field": 6
}"#;
const PROFILE_JSON: &str = r#"{
"name": "Jane Buyer", "email": "jane@example.com", "phone": "1234",
"phone_country_code": "+49",
"address": {"city": "New York", "line1": "123, King Street", "zip": "08807",
"state": "New York", "country": "US", "origin_zip": "08807"},
"profile_changes": true, "email_policy": "confirm_new", "surprise_field": 7
}"#;
const PLAN_PAGE_JSON: &str = r#"{
"data": [{"product_id": "prod_1", "price_id": "price_1", "name": "Pro",
"amount": 900, "currency": "EUR", "billing_interval": "month",
"billing_interval_count": 1}],
"has_more": false, "next_offset": 1, "surprise_field": 8
}"#;
const SUBSCRIPTION_JSON: &str = r#"{
"id": "sub_1", "status": "active", "shop_name": "Shop", "test_mode": false,
"amount_source": "price", "amount": 900, "currency": "EUR",
"capabilities": {"pause_immediately": true, "resume_immediately": false,
"cancel_immediately": true, "cancel_at_period_end": true,
"change_plan": true, "pause_voids_invoices": false},
"surprise_field": 9
}"#;
const INVOICE_JSON: &str = r#"{
"id": "inv_1", "document_number": "2026-001", "kind": "invoice", "status": "issued",
"test_mode": false,
"seller": {"name": "Shop SARL", "country": "FR", "region": null,
"vat_id": "DE123456789", "email": null},
"buyer": {"name": "Jane Buyer", "email": "jane@example.com"},
"currency": "EUR", "gross_amount": 1190, "net_amount": 1000, "tax_amount": 190,
"supply_date": "2026-01-01",
"lines": [{"description": "Pro", "quantity": 1, "unit_net_amount": 1000,
"line_net_amount": 1000, "gross_amount": 1190, "tax_rate_bp": 1900,
"included": true}],
"surprise_field": 10
}"#;
const ENROLLMENT_JSON: &str = r#"{
"subscription_id": "sub_new", "payment_id": "pay_1",
"payment_status": "requires_customer_action", "amount": 900, "currency": "EUR",
"next_action": {"type": "redirect_to_url", "redirect_to_url": "https://x"},
"client_secret": "pay_1_secret_abc", "active": false, "surprise_field": 11
}"#;
#[tokio::test]
async fn get_session_sends_the_grant_as_the_api_key() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"shop_name":"Shop","customer_name":"Jane","expires_at":1767225600,
"subscription_self_service":true,
"permissions":{"refund_requests":true,"email_policy":"read_only"},
"surprise_field":1}"#,
)]);
let session = client.buyer_portal().get_session().await.unwrap();
assert_eq!(session.expires_at, 1767225600);
assert_eq!(session.permissions.refund_requests, Some(true));
assert_eq!(session.extra["surprise_field"], 1);
assert!(!format!("{session:?}").contains("Jane"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/buyer-portal/session");
assert_eq!(seen[0].header("api-key"), Some("prd_test"));
assert_eq!(seen[0].header("authorization"), None);
}
#[tokio::test]
async fn list_cases_gets_the_cases_path() {
let (client, mock) = client_with(vec![Step::ok(CASE_LIST_JSON)]);
let cases = client.buyer_portal().list_cases().await.unwrap();
assert_eq!(cases.data[0].id, "case_1");
assert_eq!(cases.data[0].amount, Some(1200));
assert_eq!(cases.data[0].events[0].kind, "opened");
assert_eq!(cases.data[0].extra["case_surprise"], 1);
assert_eq!(cases.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/buyer-portal/cases");
}
#[tokio::test]
async fn case_evidence_encodes_the_case_id() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_JSON)]);
let evidence = client.buyer_portal().case_evidence("case/1").await.unwrap();
assert!(evidence.can_submit);
assert_eq!(evidence.rules.as_ref().unwrap().max_files, 5);
assert_eq!(evidence.deadline.as_ref().unwrap().kind, "initial");
assert_eq!(evidence.extra["surprise_field"], "x");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/cases/case%2F1/evidence"
);
}
#[tokio::test]
async fn upload_evidence_file_posts_the_upload_id_and_the_file() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_FILE_JSON)]);
let upload =
BuyerFileUpload::new("upl_12345678", "receipt.pdf", "application/pdf", b"%PDF");
let file = client
.buyer_portal()
.upload_evidence_file("case_1", &upload)
.await
.unwrap();
assert_eq!(file.id, "file_1");
assert!(!file.submitted);
assert_eq!(file.extra["surprise_field"], true);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/cases/case_1/evidence/files"
);
let content_type = seen[0].content_type.as_deref().expect("multipart");
let boundary = content_type
.strip_prefix("multipart/form-data; boundary=")
.expect("multipart content type");
let body = String::from_utf8(seen[0].body.clone().unwrap()).unwrap();
assert!(body.contains(&format!(
"--{boundary}\r\nContent-Disposition: form-data; name=\"client_upload_id\"\r\n\r\nupl_12345678\r\n"
)));
assert!(body.contains("name=\"file\"; filename=\"receipt.pdf\""));
assert!(body.contains("Content-Type: application/pdf\r\n\r\n%PDF"));
assert!(!seen[0].had_idempotency_key());
}
#[tokio::test]
async fn download_evidence_file_returns_the_bytes() {
let (client, mock) = client_with(vec![Step::ok("%PDF-1.7")]);
let bytes = client
.buyer_portal()
.download_evidence_file("case_1", "file/1")
.await
.unwrap();
assert_eq!(bytes, b"%PDF-1.7");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/cases/case_1/evidence/files/file%2F1"
);
assert_eq!(seen[0].header("accept"), Some("*/*"));
}
#[tokio::test]
async fn remove_evidence_file_deletes_and_accepts_an_empty_body() {
let (client, mock) = client_with(vec![Step::ok("")]);
client
.buyer_portal()
.remove_evidence_file("case_1", "file_1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/cases/case_1/evidence/files/file_1"
);
}
#[tokio::test]
async fn remove_evidence_file_accepts_a_json_body_too() {
let (client, _mock) = client_with(vec![Step::ok(r#"{"deleted":true}"#)]);
client
.buyer_portal()
.remove_evidence_file("case_1", "file_1")
.await
.unwrap();
}
#[tokio::test]
async fn submit_evidence_posts_the_submission() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_ENTRY_JSON)]);
let params = BuyerEvidenceSubmitRequest::new("sub_12345678")
.explanation("It never arrived")
.files(vec!["file_1".to_string()]);
let entry = client
.buyer_portal()
.submit_evidence("case_1", ¶ms)
.await
.unwrap();
assert_eq!(entry.kind, "submitted");
assert_eq!(entry.extra["surprise_field"], 2);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/cases/case_1/evidence/submissions"
);
assert_eq!(
seen[0].body_json(),
json!({
"client_submission_id": "sub_12345678",
"explanation": "It never arrived",
"files": ["file_1"]
})
);
}
#[tokio::test]
async fn request_evidence_extension_posts_the_message() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_ENTRY_JSON)]);
client
.buyer_portal()
.request_evidence_extension(
"case_1",
&BuyerEvidenceExtensionRequest::new("Waiting on the courier"),
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/cases/case_1/evidence/extension-requests"
);
assert_eq!(
seen[0].body_json(),
json!({"message": "Waiting on the courier"})
);
}
#[tokio::test]
async fn list_conversations_gets_the_conversations_path() {
let (client, mock) = client_with(vec![Step::ok(CONVERSATION_LIST_JSON)]);
let list = client.buyer_portal().list_conversations().await.unwrap();
assert_eq!(list.data[0].shop, "pro_1");
assert!(list.data[0].unread);
assert_eq!(list.extra["surprise_field"], 3);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/buyer-portal/conversations");
}
#[tokio::test]
async fn list_messages_sends_every_query_parameter() {
let (client, mock) = client_with(vec![Step::ok(MESSAGE_PAGE_JSON)]);
let params = BuyerConversationParams::new("pro_1")
.test_mode(true)
.before("msg_9")
.limit(20);
let page = client
.buyer_portal()
.list_messages(Some(¶ms))
.await
.unwrap();
assert!(page.attachment_rules.enabled);
assert_eq!(page.attachment_rules.max_files, 5);
assert_eq!(page.extra["surprise_field"], 4);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/messages?shop=pro_1&test_mode=true&before=msg_9&limit=20"
);
}
#[tokio::test]
async fn send_message_posts_the_message() {
let (client, mock) = client_with(vec![Step::ok(MESSAGE_JSON)]);
let params = BuyerMessageCreateRequest::new("msg_12345678")
.shop("pro_1")
.body("Hello")
.purchase("pay_1")
.attachments(vec!["att_1".to_string()]);
let message = client.buyer_portal().send_message(¶ms).await.unwrap();
assert_eq!(message.id, "msg_1");
assert_eq!(message.extra["surprise_field"], 5);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/buyer-portal/messages");
assert_eq!(
seen[0].body_json(),
json!({
"client_message_id": "msg_12345678",
"shop": "pro_1",
"body": "Hello",
"purchase": "pay_1",
"attachments": ["att_1"]
})
);
}
#[tokio::test]
async fn send_message_is_not_replayed_on_a_server_error() {
let (client, mock) = client_with_retries(
vec![
Step::status(500, r#"{"error":{"message":"boom"}}"#),
Step::ok(MESSAGE_JSON),
],
2,
);
let params = BuyerMessageCreateRequest::new("msg_12345678").body("Hello");
assert!(client.buyer_portal().send_message(¶ms).await.is_err());
assert_eq!(mock.call_count(), 1);
}
#[tokio::test]
async fn mark_messages_read_posts_with_the_query_and_no_body() {
let (client, mock) = client_with(vec![Step::ok(CONVERSATION_LIST_JSON)]);
let params = BuyerConversationParams::new("pro_1");
client
.buyer_portal()
.mark_messages_read(Some(¶ms))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/messages/read?shop=pro_1"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn upload_message_file_posts_multipart_with_the_shop_query() {
let (client, mock) = client_with(vec![Step::ok(ATTACHMENT_JSON)]);
let upload = BuyerFileUpload::new("upl_12345678", "photo.png", "image/png", b"PNG!");
let params = BuyerAttachmentParams::new("pro_1").test_mode(false);
let file = client
.buyer_portal()
.upload_message_file(&upload, Some(¶ms))
.await
.unwrap();
assert_eq!(file.id, "att_1");
assert_eq!(file.extra["surprise_field"], 6);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/messages/files?shop=pro_1&test_mode=false"
);
let body = String::from_utf8(seen[0].body.clone().unwrap()).unwrap();
assert!(body.contains("name=\"client_upload_id\"\r\n\r\nupl_12345678\r\n"));
assert!(body.contains("Content-Type: image/png\r\n\r\nPNG!"));
assert!(
seen[0]
.content_type
.as_deref()
.unwrap()
.starts_with("multipart/form-data; boundary=")
);
}
#[tokio::test]
async fn download_message_file_gets_the_bytes_with_the_shop_query() {
let (client, mock) = client_with(vec![Step::ok("PNG!")]);
let params = BuyerAttachmentParams::new("pro_1");
let bytes = client
.buyer_portal()
.download_message_file("att/1", Some(¶ms))
.await
.unwrap();
assert_eq!(bytes, b"PNG!");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/messages/files/att%2F1?shop=pro_1"
);
assert_eq!(seen[0].header("accept"), Some("*/*"));
}
#[tokio::test]
async fn remove_message_file_deletes_with_the_shop_query() {
let (client, mock) = client_with(vec![Step::ok(r#"{"deleted":true,"id":"x"}"#)]);
let params = BuyerAttachmentParams::new("pro_1");
client
.buyer_portal()
.remove_message_file("att_1", Some(¶ms))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/messages/files/att_1?shop=pro_1"
);
}
#[tokio::test]
async fn get_profile_decodes_and_redacts_the_details() {
let (client, mock) = client_with(vec![Step::ok(PROFILE_JSON)]);
let profile = client.buyer_portal().get_profile().await.unwrap();
assert_eq!(profile.email.as_deref(), Some("jane@example.com"));
assert_eq!(
profile.address.as_ref().unwrap().city.as_deref(),
Some("New York")
);
assert_eq!(profile.email_policy, "confirm_new");
assert_eq!(profile.extra["surprise_field"], 7);
let debug = format!("{profile:?}");
assert!(!debug.contains("jane@example.com"), "{debug}");
assert!(!debug.contains("Jane Buyer"), "{debug}");
assert!(!debug.contains("King Street"), "{debug}");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/buyer-portal/profile");
}
#[tokio::test]
async fn update_profile_posts_only_the_fields_set() {
let (client, mock) = client_with(vec![Step::ok(PROFILE_JSON)]);
let params = BuyerPortalProfileUpdateRequest::new()
.name("Jane Buyer")
.phone("+49", "1234")
.address(AddressDetails {
city: Some("Berlin".to_string()),
..Default::default()
});
assert!(!format!("{params:?}").contains("Jane Buyer"));
client.buyer_portal().update_profile(¶ms).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/buyer-portal/profile");
assert_eq!(
seen[0].body_json(),
json!({
"name": "Jane Buyer",
"phone": "1234",
"phone_country_code": "+49",
"address": {"city": "Berlin"}
})
);
}
#[tokio::test]
async fn change_contact_email_posts_the_tagged_command() {
let (client, mock) = client_with(vec![
Step::ok(
r#"{"status":"pending_confirmation","operation_id":"op_1",
"delivery":{"confirmation":"sent","previous_notice":"not_required"},
"surprise_field":1}"#,
),
Step::ok(r#"{"status":"refused","reason":"invalid_proof"}"#),
]);
let portal = client.buyer_portal();
let request = BuyerPortalContactEmailCommand::request("op_1", "new@example.com");
assert!(!format!("{request:?}").contains("new@example.com"));
let pending = portal.change_contact_email(&request).await.unwrap();
assert_eq!(pending.status, "pending_confirmation");
assert_eq!(pending.delivery.as_ref().unwrap().confirmation, "sent");
assert_eq!(pending.extra["surprise_field"], 1);
let confirm = BuyerPortalContactEmailCommand::confirm("op_1", "123456");
let refused = portal.change_contact_email(&confirm).await.unwrap();
assert_eq!(refused.reason.as_deref(), Some("invalid_proof"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/profile/contact-email"
);
assert_eq!(
seen[0].body_json(),
json!({"action": "request", "operation_id": "op_1", "email": "new@example.com"})
);
assert_eq!(
seen[1].body_json(),
json!({"action": "confirm", "operation_id": "op_1", "proof": "123456"})
);
}
#[tokio::test]
async fn create_refund_request_posts_to_the_purchase() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"id":"rr_1","status":"requested","reason":"not_received",
"message":"Never came","amount":500,"currency":"EUR",
"created_at":"2026-01-01T00:00:00Z","surprise_field":1}"#,
)]);
let params =
BuyerPortalRefundRequestCreateRequest::new("not_received", "Never came").amount(500);
let request = client
.buyer_portal()
.create_refund_request("pay/1", ¶ms)
.await
.unwrap();
assert_eq!(request.status, "requested");
assert_eq!(request.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/purchases/pay%2F1/refund-requests"
);
assert_eq!(
seen[0].body_json(),
json!({"reason": "not_received", "message": "Never came", "amount": 500})
);
}
#[tokio::test]
async fn list_invoices_sends_the_page_query() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"data":[{INVOICE_JSON}],"total_count":1,"limit":10,"offset":0,"surprise_field":1}}"#
))]);
let params = BuyerPortalPageParams::new().limit(10).offset(0);
let page = client
.buyer_portal()
.list_invoices(Some(¶ms))
.await
.unwrap();
assert_eq!(page.data[0].lines[0].tax_rate_bp, Some(1900));
assert_eq!(page.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/invoices?limit=10&offset=0"
);
}
#[tokio::test]
async fn retrieve_invoice_encodes_the_id_and_redacts_the_parties() {
let (client, mock) = client_with(vec![Step::ok(INVOICE_JSON)]);
let invoice = client
.buyer_portal()
.retrieve_invoice("inv/1")
.await
.unwrap();
assert_eq!(invoice.gross_amount, 1190);
assert_eq!(invoice.buyer.email.as_deref(), Some("jane@example.com"));
assert_eq!(invoice.extra["surprise_field"], 10);
assert_eq!(invoice.seller.vat_id.as_deref(), Some("DE123456789"));
assert_eq!(invoice.seller.region, None);
assert!(!format!("{invoice:?}").contains("jane@example.com"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/invoices/inv%2F1"
);
}
#[tokio::test]
async fn download_invoice_pdf_asks_for_a_pdf() {
let (client, mock) = client_with(vec![Step::ok("%PDF-1.7")]);
let bytes = client
.buyer_portal()
.download_invoice_pdf("inv_1")
.await
.unwrap();
assert_eq!(bytes, b"%PDF-1.7");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/invoices/inv_1/pdf"
);
assert_eq!(seen[0].header("accept"), Some("application/pdf"));
}
#[tokio::test]
async fn list_purchases_decodes_the_page() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[{"id":"pay_1","kind":"payment","status":"succeeded","amount":1200,
"currency":"EUR","created_at":"2026-01-01T00:00:00Z","shop_name":"Shop",
"test_mode":false,"receipt_availability":"available",
"lines":[{"description":"Mug","quantity":2,"unit_amount":600}],
"refundable_amount":1200,"refund_request_allowed":true}],
"total_count":1,"limit":20,"offset":0,"surprise_field":1}"#,
)]);
let page = client.buyer_portal().list_purchases(None).await.unwrap();
assert_eq!(page.data[0].lines[0].quantity, 2);
assert!(page.data[0].refund_request_allowed);
assert_eq!(page.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/buyer-portal/purchases");
}
#[tokio::test]
async fn list_subscriptions_sends_the_page_query() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"data":[{SUBSCRIPTION_JSON}],"total_count":1,"limit":5,"offset":5,"surprise_field":1}}"#
))]);
let params = BuyerPortalPageParams::new().limit(5).offset(5);
let page = client
.buyer_portal()
.list_subscriptions(Some(¶ms))
.await
.unwrap();
assert!(page.data[0].capabilities.change_plan);
assert_eq!(page.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/subscriptions?limit=5&offset=5"
);
}
#[tokio::test]
async fn act_on_subscription_posts_the_action() {
let (client, mock) = client_with(vec![Step::ok(SUBSCRIPTION_JSON)]);
let sub = client
.buyer_portal()
.act_on_subscription("sub/1", &BuyerPortalSubscriptionActionRequest::new("pause"))
.await
.unwrap();
assert_eq!(sub.id, "sub_1");
assert_eq!(sub.extra["surprise_field"], 9);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/subscriptions/sub%2F1/actions"
);
assert_eq!(seen[0].body_json(), json!({"action": "pause"}));
}
#[tokio::test]
async fn list_subscription_plans_gets_the_plans_sub_path() {
let (client, mock) = client_with(vec![Step::ok(PLAN_PAGE_JSON)]);
let page = client
.buyer_portal()
.list_subscription_plans("sub_1", Some(&BuyerPortalPageParams::new().limit(3)))
.await
.unwrap();
assert_eq!(page.data[0].billing_interval, "month");
assert_eq!(page.next_offset, 1);
assert_eq!(page.extra["surprise_field"], 8);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/subscriptions/sub_1/plans?limit=3"
);
}
#[tokio::test]
async fn change_subscription_plan_posts_the_confirmed_terms() {
let (client, mock) = client_with(vec![Step::ok(SUBSCRIPTION_JSON)]);
let params = BuyerPortalPlanChangeRequest::new("prod_2", "price_2", 1900, "EUR");
client
.buyer_portal()
.change_subscription_plan("sub_1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/subscriptions/sub_1/change-plan"
);
assert_eq!(
seen[0].body_json(),
json!({
"product_id": "prod_2",
"price_id": "price_2",
"confirmed_amount": 1900,
"confirmed_currency": "EUR"
})
);
}
#[tokio::test]
async fn list_native_plans_encodes_the_profile_id() {
let (client, mock) = client_with(vec![Step::ok(PLAN_PAGE_JSON)]);
client
.buyer_portal()
.list_native_plans("pro/1", None)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/subscriptions/native/plans/pro%2F1"
);
}
#[tokio::test]
async fn enroll_native_posts_the_disclosed_terms() {
let (client, mock) = client_with(vec![Step::ok(ENROLLMENT_JSON)]);
let params = NativeEnrollmentRequest::new("sub_new", "pro_1", "prod_1", "price_1")
.disclosed(900, "EUR", "month", 1)
.recurring_terms_accepted(true)
.payment_details(json!({"return_url": "https://shop.example/return"}));
assert!(!format!("{params:?}").contains("shop.example"));
let enrollment = client.buyer_portal().enroll_native(¶ms).await.unwrap();
assert_eq!(enrollment.payment_status, "requires_customer_action");
assert_eq!(
enrollment.next_action.as_ref().unwrap()["type"],
"redirect_to_url"
);
assert_eq!(enrollment.extra["surprise_field"], 11);
assert!(!format!("{enrollment:?}").contains("pay_1_secret_abc"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/subscriptions/native/enroll"
);
assert_eq!(
seen[0].body_json(),
json!({
"subscription_id": "sub_new",
"profile_id": "pro_1",
"product_id": "prod_1",
"price_id": "price_1",
"disclosed_amount": 900,
"disclosed_currency": "EUR",
"disclosed_interval": "month",
"disclosed_interval_count": 1,
"recurring_terms_accepted": true,
"payment_details": {"return_url": "https://shop.example/return"}
})
);
assert!(!seen[0].had_idempotency_key());
}
#[tokio::test]
async fn get_native_enrollment_sends_the_profile_query() {
let (client, mock) = client_with(vec![Step::ok(ENROLLMENT_JSON)]);
client
.buyer_portal()
.get_native_enrollment("sub/new", "pro_1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-portal/subscriptions/native/enroll/sub%2Fnew?profile_id=pro_1"
);
}
#[tokio::test]
async fn abandon_native_enrollment_posts_with_the_profile_query() {
let (client, mock) =
client_with(vec![Step::ok(r#"{"abandoned":true,"surprise_field":1}"#)]);
let out = client
.buyer_portal()
.abandon_native_enrollment("sub_new", "pro_1")
.await
.unwrap();
assert!(out.abandoned);
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/buyer-portal/subscriptions/native/enroll/sub_new/abandon?profile_id=pro_1"
);
assert!(seen[0].body.is_none());
}
fn assert_named_covers(value: Value, named: &[&str], const_name: &str) {
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
named.contains(&key.as_str()),
"{const_name} is missing wire key `{key}`"
);
}
}
#[test]
fn buyer_evidence_submit_request_named_fields_are_complete() {
let req = BuyerEvidenceSubmitRequest::new("sub_12345678")
.explanation("x")
.files(vec!["f".to_string()]);
assert_named_covers(
serde_json::to_value(req).unwrap(),
BUYER_EVIDENCE_SUBMIT_REQUEST_NAMED,
"BUYER_EVIDENCE_SUBMIT_REQUEST_NAMED",
);
}
#[test]
fn buyer_message_create_request_named_fields_are_complete() {
let req = BuyerMessageCreateRequest::new("msg_12345678")
.shop("pro_1")
.test_mode(true)
.body("x")
.purchase("pay_1")
.attachments(vec!["att_1".to_string()]);
assert_named_covers(
serde_json::to_value(req).unwrap(),
BUYER_MESSAGE_CREATE_REQUEST_NAMED,
"BUYER_MESSAGE_CREATE_REQUEST_NAMED",
);
}
#[test]
fn buyer_portal_profile_update_request_named_fields_are_complete() {
let req = BuyerPortalProfileUpdateRequest::new()
.name("x")
.phone("+49", "1")
.tax_registration_id("DE1")
.address(AddressDetails::default());
assert_named_covers(
serde_json::to_value(req).unwrap(),
BUYER_PORTAL_PROFILE_UPDATE_REQUEST_NAMED,
"BUYER_PORTAL_PROFILE_UPDATE_REQUEST_NAMED",
);
}
#[test]
fn buyer_portal_refund_request_create_request_named_fields_are_complete() {
let req = BuyerPortalRefundRequestCreateRequest::new("other", "x").amount(1);
assert_named_covers(
serde_json::to_value(req).unwrap(),
BUYER_PORTAL_REFUND_REQUEST_CREATE_REQUEST_NAMED,
"BUYER_PORTAL_REFUND_REQUEST_CREATE_REQUEST_NAMED",
);
}
#[test]
fn buyer_portal_plan_change_request_named_fields_are_complete() {
let req = BuyerPortalPlanChangeRequest::new("prod", "price", 1, "EUR");
assert_named_covers(
serde_json::to_value(req).unwrap(),
BUYER_PORTAL_PLAN_CHANGE_REQUEST_NAMED,
"BUYER_PORTAL_PLAN_CHANGE_REQUEST_NAMED",
);
}
#[test]
fn native_enrollment_request_named_fields_are_complete() {
let req = NativeEnrollmentRequest::new("sub", "pro", "prod", "price")
.disclosed(1, "EUR", "month", 1)
.recurring_terms_accepted(true);
assert_named_covers(
serde_json::to_value(req).unwrap(),
NATIVE_ENROLLMENT_REQUEST_NAMED,
"NATIVE_ENROLLMENT_REQUEST_NAMED",
);
}
#[tokio::test]
async fn a_colliding_extra_key_is_refused_before_sending() {
let (client, mock) = client_with(vec![]);
let mut req = BuyerMessageCreateRequest::new("msg_12345678");
req.extra.insert("body".to_string(), json!("other"));
match client.buyer_portal().send_message(&req).await.unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("body")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
assert_eq!(mock.call_count(), 0);
}
fn keyed_client(
ok: &str,
) -> (
crate::Delopay,
std::sync::Arc<crate::http::mock::MockTransport>,
) {
let (client, mock) = crate::http::mock::client_with_retries(
vec![
Step::status(503, r#"{"error":{"message":"down"}}"#),
Step::ok(ok),
],
2,
);
(client.with_idempotency_key("idem_client_wide"), mock)
}
fn assert_sent_once_without_key(mock: &crate::http::mock::MockTransport) {
assert_eq!(
mock.call_count(),
1,
"a 503 on this write must not be retried"
);
assert!(
!mock.seen.lock().unwrap()[0].had_idempotency_key(),
"the client-wide key must not be sent"
);
}
#[tokio::test]
async fn portal_writes_ignore_the_client_wide_idempotency_key() {
let (client, mock) = keyed_client(MESSAGE_JSON);
let params = BuyerMessageCreateRequest::new("msg_12345678").body("Hello");
assert!(client.buyer_portal().send_message(¶ms).await.is_err());
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client(EVIDENCE_FILE_JSON);
let upload = BuyerFileUpload::new("upl_12345678", "a.pdf", "application/pdf", b"%PDF");
assert!(
client
.buyer_portal()
.upload_evidence_file("case_1", &upload)
.await
.is_err()
);
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client("");
assert!(
client
.buyer_portal()
.remove_message_file("att_1", Some(&BuyerAttachmentParams::new("pro_1")))
.await
.is_err()
);
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client(r#"{"abandoned":true}"#);
assert!(
client
.buyer_portal()
.abandon_native_enrollment("sub_1", "pro_1")
.await
.is_err()
);
assert_sent_once_without_key(&mock);
}
}