use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::Result;
use crate::core::models::buyer_account::{
BuyerAccountAvailability, BuyerAccountConfirmation, BuyerAccountInvoiceList,
BuyerAccountPortal, BuyerAccountPurchasePage, BuyerAccountRefundRequestList,
BuyerAccountSession, BuyerAccountSessionInfo, BuyerAccountShopList, BuyerAccountSignInResponse,
BuyerAccountSubscriptionList, BuyerNoticeSettings,
};
use crate::core::models::buyer_case::{
BuyerCaseList, BuyerEvidence, BuyerEvidenceEntry, BuyerEvidenceFile,
};
use crate::core::models::buyer_conversation::{
BuyerConversationAttachment, BuyerPortalConversationList, BuyerPortalMessage,
BuyerPortalMessagePage,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
use crate::resources::buyer_portal::{
ANY_FILE, BuyerAttachmentParams, BuyerConversationParams, BuyerEvidenceExtensionRequest,
BuyerEvidenceSubmitRequest, BuyerFileUpload, BuyerMessageCreateRequest, check_extra,
delete_ignoring_body,
};
#[derive(Debug, Clone)]
pub struct BuyerAccount {
inner: Arc<Inner>,
}
impl BuyerAccount {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn availability(&self) -> Result<BuyerAccountAvailability> {
self.get("/buyer-account/availability", &[]).await
}
pub async fn start_sign_in(
&self,
params: &BuyerAccountSignInRequest,
) -> Result<BuyerAccountSignInResponse> {
params.validate()?;
self.post("/buyer-account/sign-in", params).await
}
pub async fn verify_code(
&self,
params: &BuyerAccountVerifyCodeRequest,
) -> Result<BuyerAccountSession> {
params.validate()?;
self.post("/buyer-account/sign-in/code", params).await
}
pub async fn verify_link(
&self,
params: &BuyerAccountVerifyLinkRequest,
) -> Result<BuyerAccountSession> {
self.post("/buyer-account/sign-in/link", params).await
}
pub async fn get_session(&self) -> Result<BuyerAccountSessionInfo> {
self.get("/buyer-account/session", &[]).await
}
pub async fn sign_out(&self) -> Result<()> {
delete_ignoring_body(&self.inner, "/buyer-account/session", &[]).await
}
pub async fn notice_settings(&self) -> Result<BuyerNoticeSettings> {
self.get("/buyer-account/notice-settings", &[]).await
}
pub async fn set_notice_settings(
&self,
params: &BuyerNoticeSettingsRequest,
) -> Result<BuyerNoticeSettings> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Put,
"/buyer-account/notice-settings",
Some(&body),
&[],
None,
)
.await
}
pub async fn list_purchases(
&self,
params: Option<&BuyerAccountPurchaseParams>,
) -> Result<BuyerAccountPurchasePage> {
let query = params.map(BuyerAccountPurchaseParams::to_query);
self.get("/buyer-account/purchases", query.as_deref().unwrap_or(&[]))
.await
}
pub async fn list_shops(&self) -> Result<BuyerAccountShopList> {
self.get("/buyer-account/shops", &[]).await
}
pub async fn list_subscriptions(
&self,
params: Option<&BuyerAccountSectionParams>,
) -> Result<BuyerAccountSubscriptionList> {
let query = params.map(BuyerAccountSectionParams::to_query);
self.get(
"/buyer-account/subscriptions",
query.as_deref().unwrap_or(&[]),
)
.await
}
pub async fn list_invoices(
&self,
params: Option<&BuyerAccountSectionParams>,
) -> Result<BuyerAccountInvoiceList> {
let query = params.map(BuyerAccountSectionParams::to_query);
self.get("/buyer-account/invoices", query.as_deref().unwrap_or(&[]))
.await
}
pub async fn list_refund_requests(
&self,
params: Option<&BuyerAccountSectionParams>,
) -> Result<BuyerAccountRefundRequestList> {
let query = params.map(BuyerAccountSectionParams::to_query);
self.get(
"/buyer-account/refund-requests",
query.as_deref().unwrap_or(&[]),
)
.await
}
pub async fn list_cases(&self, shop: Option<&str>) -> Result<BuyerCaseList> {
self.get("/buyer-account/cases", &shop_query(shop)).await
}
pub async fn list_conversations(
&self,
shop: Option<&str>,
) -> Result<BuyerPortalConversationList> {
self.get("/buyer-account/conversations", &shop_query(shop))
.await
}
pub async fn list_record_messages(
&self,
record: &str,
params: &BuyerConversationParams,
) -> Result<BuyerPortalMessagePage> {
let path = format!("{}/messages", record_path(record));
self.get(&path, ¶ms.to_query()).await
}
pub async fn send_record_message(
&self,
record: &str,
params: &BuyerMessageCreateRequest,
) -> Result<BuyerPortalMessage> {
params.validate()?;
let path = format!("{}/messages", record_path(record));
self.post(&path, params).await
}
pub async fn mark_record_messages_read(
&self,
record: &str,
params: &BuyerConversationParams,
) -> Result<BuyerPortalConversationList> {
let path = format!("{}/messages/read", record_path(record));
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, None, ¶ms.to_query(), None)
.await
}
pub async fn upload_record_message_file(
&self,
record: &str,
upload: &BuyerFileUpload<'_>,
params: &BuyerAttachmentParams,
) -> Result<BuyerConversationAttachment> {
let path = format!("{}/messages/files", record_path(record));
let form = upload.encode();
self.inner
.request_with_content_type_and_query(
HttpMethod::Post,
&path,
¶ms.to_query(),
&form.body,
&form.content_type,
)
.await
}
pub async fn download_record_message_file(
&self,
record: &str,
file_id: &str,
params: &BuyerAttachmentParams,
) -> Result<Vec<u8>> {
let path = format!(
"{}/messages/files/{}",
record_path(record),
encode_segment(file_id)
);
self.inner
.request_bytes(HttpMethod::Get, &path, ¶ms.to_query(), ANY_FILE)
.await
}
pub async fn remove_record_message_file(
&self,
record: &str,
file_id: &str,
params: &BuyerAttachmentParams,
) -> Result<()> {
let path = format!(
"{}/messages/files/{}",
record_path(record),
encode_segment(file_id)
);
delete_ignoring_body(&self.inner, &path, ¶ms.to_query()).await
}
pub async fn confirm(
&self,
params: &BuyerAccountConfirmRequest,
) -> Result<BuyerAccountConfirmation> {
self.post("/buyer-account/confirmations", params).await
}
pub async fn open_portal(&self, record: &str) -> Result<BuyerAccountPortal> {
let path = format!("{}/portal", record_path(record));
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn case_evidence(&self, record: &str, case_id: &str) -> Result<BuyerEvidence> {
self.get(&evidence_path(record, case_id), &[]).await
}
pub async fn upload_evidence_file(
&self,
record: &str,
case_id: &str,
upload: &BuyerFileUpload<'_>,
) -> Result<BuyerEvidenceFile> {
let path = format!("{}/files", evidence_path(record, 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,
record: &str,
case_id: &str,
file_id: &str,
) -> Result<Vec<u8>> {
let path = format!(
"{}/files/{}",
evidence_path(record, case_id),
encode_segment(file_id)
);
self.inner
.request_bytes(HttpMethod::Get, &path, &[], ANY_FILE)
.await
}
pub async fn remove_evidence_file(
&self,
record: &str,
case_id: &str,
file_id: &str,
) -> Result<()> {
let path = format!(
"{}/files/{}",
evidence_path(record, case_id),
encode_segment(file_id)
);
delete_ignoring_body(&self.inner, &path, &[]).await
}
pub async fn submit_evidence(
&self,
record: &str,
case_id: &str,
params: &BuyerEvidenceSubmitRequest,
) -> Result<BuyerEvidenceEntry> {
params.validate()?;
let path = format!("{}/submissions", evidence_path(record, case_id));
self.post(&path, params).await
}
pub async fn request_evidence_extension(
&self,
record: &str,
case_id: &str,
params: &BuyerEvidenceExtensionRequest,
) -> Result<BuyerEvidenceEntry> {
let path = format!("{}/extension-requests", evidence_path(record, case_id));
self.post(&path, params).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,
) -> Result<T> {
let body = to_json_vec(body)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, path, Some(&body), &[], None)
.await
}
}
fn record_path(record: &str) -> String {
format!("/buyer-account/records/{}", encode_segment(record))
}
fn evidence_path(record: &str, case_id: &str) -> String {
format!(
"{}/cases/{}/evidence",
record_path(record),
encode_segment(case_id)
)
}
fn shop_query(shop: Option<&str>) -> Vec<(&'static str, String)> {
shop.map(|s| vec![("shop", s.to_string())])
.unwrap_or_default()
}
#[derive(Clone, Default, Serialize)]
pub struct BuyerAccountSignInRequest {
pub email: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl BuyerAccountSignInRequest {
pub fn new(email: impl Into<String>) -> Self {
Self {
email: email.into(),
..Default::default()
}
}
#[must_use]
pub fn locale(mut self, locale: impl Into<String>) -> Self {
self.locale = Some(locale.into());
self
}
}
impl std::fmt::Debug for BuyerAccountSignInRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BuyerAccountSignInRequest")
.field("email", &"<redacted>")
.field("locale", &self.locale)
.finish_non_exhaustive()
}
}
const BUYER_ACCOUNT_SIGN_IN_REQUEST_NAMED: &[&str] = &["email", "locale"];
impl ValidateRequest for BuyerAccountSignInRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
BUYER_ACCOUNT_SIGN_IN_REQUEST_NAMED,
"BuyerAccountSignInRequest",
)
}
}
#[derive(Clone, Default, Serialize)]
pub struct BuyerAccountVerifyCodeRequest {
pub email: String,
pub code: String,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl BuyerAccountVerifyCodeRequest {
pub fn new(email: impl Into<String>, code: impl Into<String>) -> Self {
Self {
email: email.into(),
code: code.into(),
extra: serde_json::Map::new(),
}
}
}
impl std::fmt::Debug for BuyerAccountVerifyCodeRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BuyerAccountVerifyCodeRequest")
.field("email", &"<redacted>")
.field("code", &"<redacted>")
.finish_non_exhaustive()
}
}
const BUYER_ACCOUNT_VERIFY_CODE_REQUEST_NAMED: &[&str] = &["email", "code"];
impl ValidateRequest for BuyerAccountVerifyCodeRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
BUYER_ACCOUNT_VERIFY_CODE_REQUEST_NAMED,
"BuyerAccountVerifyCodeRequest",
)
}
}
#[derive(Clone, Serialize)]
pub struct BuyerAccountVerifyLinkRequest {
pub token: String,
}
impl BuyerAccountVerifyLinkRequest {
pub fn new(token: impl Into<String>) -> Self {
Self {
token: token.into(),
}
}
}
impl std::fmt::Debug for BuyerAccountVerifyLinkRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BuyerAccountVerifyLinkRequest")
.field("token", &"<redacted>")
.finish()
}
}
#[derive(Debug, Clone, Copy, Serialize)]
pub struct BuyerNoticeSettingsRequest {
pub replies: bool,
pub case_updates: bool,
}
impl BuyerNoticeSettingsRequest {
pub fn new(replies: bool, case_updates: bool) -> Self {
Self {
replies,
case_updates,
}
}
}
#[derive(Clone, Serialize)]
pub struct BuyerAccountConfirmRequest {
pub portal_token: String,
}
impl BuyerAccountConfirmRequest {
pub fn new(portal_token: impl Into<String>) -> Self {
Self {
portal_token: portal_token.into(),
}
}
}
impl std::fmt::Debug for BuyerAccountConfirmRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BuyerAccountConfirmRequest")
.field("portal_token", &"<redacted>")
.finish()
}
}
#[derive(Debug, Clone, Default)]
pub struct BuyerAccountPurchaseParams {
pub limit: Option<i64>,
pub cursor: Option<String>,
pub shop: Option<String>,
}
impl BuyerAccountPurchaseParams {
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 cursor(mut self, cursor: impl Into<String>) -> Self {
self.cursor = Some(cursor.into());
self
}
#[must_use]
pub fn shop(mut self, shop: impl Into<String>) -> Self {
self.shop = Some(shop.into());
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.cursor {
q.push(("cursor", v.clone()));
}
if let Some(v) = &self.shop {
q.push(("shop", v.clone()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct BuyerAccountSectionParams {
pub shop: Option<String>,
pub cursor: Option<String>,
pub limit: Option<i64>,
pub test_mode: Option<bool>,
}
impl BuyerAccountSectionParams {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn shop(mut self, shop: impl Into<String>) -> Self {
self.shop = Some(shop.into());
self
}
#[must_use]
pub fn cursor(mut self, cursor: impl Into<String>) -> Self {
self.cursor = Some(cursor.into());
self
}
#[must_use]
pub fn limit(mut self, limit: i64) -> Self {
self.limit = Some(limit);
self
}
#[must_use]
pub fn test_mode(mut self, test_mode: bool) -> Self {
self.test_mode = Some(test_mode);
self
}
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.cursor {
q.push(("cursor", v.clone()));
}
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.test_mode {
q.push(("test_mode", v.to_string()));
}
q
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const SESSION_JSON: &str = r#"{
"token": "bas_secret_token", "expires_at": 1767225600,
"email": "j***@example.com", "surprise_field": 1
}"#;
const CONVERSATION_LIST_JSON: &str = r#"{
"data": [{
"id": "conv_1", "record": "rec_1", "shop": "pro_1", "shop_name": "Shop",
"test_mode": false, "status": "open", "last_message_at": "2026-01-01T00:00:00Z",
"last_message_by": "buyer", "unread": false
}],
"unconfirmed_records": true, "surprise_field": 2
}"#;
const MESSAGE_PAGE_JSON: &str = r#"{
"conversation": {"id": "conv_1", "shop": "pro_1", "shop_name": "Shop",
"test_mode": false, "status": "closed",
"last_message_at": "2026-01-01T00:00:00Z",
"last_message_by": "merchant", "unread": true},
"messages": [{"id": "msg_1", "sender": "merchant", "sender_name": "Sam",
"body": "Hi", "attachments": [], "created_at": "2026-01-01T00:00:00Z"}],
"has_more": true,
"case_updates": [{"case": "case_1", "kind": "dispute",
"event": {"at": "2026-01-01T00:00:00Z", "kind": "opened",
"actor": "provider"}}],
"attachment_rules": {"enabled": false, "file_types": [],
"max_file_megabytes": 0, "max_files": 0},
"surprise_field": 3
}"#;
const EVIDENCE_JSON: &str = r#"{
"available": false, "unavailable_reason": "case_closed",
"can_submit": false, "can_request_extension": false, "extension_requested": false,
"saved_files": [], "history": [], "surprise_field": 4
}"#;
const EVIDENCE_FILE_JSON: &str = r#"{
"id": "file_1", "file_name": "photo.png", "file_type": "png", "size_bytes": 4,
"uploaded_at": "2026-01-01T00:00:00Z", "submitted": false, "surprise_field": 5
}"#;
const EVIDENCE_ENTRY_JSON: &str = r#"{
"id": "ent_1", "kind": "extension_requested", "actor": "buyer",
"at": "2026-01-01T00:00:00Z", "files": [], "surprise_field": 6
}"#;
#[tokio::test]
async fn availability_gets_the_availability_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"enabled":true,"methods":["code","magic_link"],"surprise_field":1}"#,
)]);
let out = client.buyer_account().availability().await.unwrap();
assert!(out.enabled);
assert_eq!(out.methods, ["code", "magic_link"]);
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/buyer-account/availability");
}
#[tokio::test]
async fn start_sign_in_posts_the_address_and_locale() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"methods":["code"],"expires_in_seconds":600,"surprise_field":1}"#,
)]);
let params = BuyerAccountSignInRequest::new("buyer@example.com").locale("de");
assert!(!format!("{params:?}").contains("buyer@example.com"));
let out = client.buyer_account().start_sign_in(¶ms).await.unwrap();
assert_eq!(out.expires_in_seconds, 600);
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-account/sign-in");
assert_eq!(
seen[0].body_json(),
json!({"email": "buyer@example.com", "locale": "de"})
);
}
#[tokio::test]
async fn verify_code_posts_the_code_and_redacts_the_session() {
let (client, mock) = client_with(vec![Step::ok(SESSION_JSON)]);
let params = BuyerAccountVerifyCodeRequest::new("buyer@example.com", "123456");
assert!(!format!("{params:?}").contains("123456"));
let session = client.buyer_account().verify_code(¶ms).await.unwrap();
assert_eq!(session.token, "bas_secret_token");
assert_eq!(session.extra["surprise_field"], 1);
assert!(!format!("{session:?}").contains("bas_secret_token"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/buyer-account/sign-in/code");
assert_eq!(
seen[0].body_json(),
json!({"email": "buyer@example.com", "code": "123456"})
);
}
#[tokio::test]
async fn verify_link_posts_the_link_token() {
let (client, mock) = client_with(vec![Step::ok(SESSION_JSON)]);
let params = BuyerAccountVerifyLinkRequest::new("lnk_abc");
assert!(!format!("{params:?}").contains("lnk_abc"));
client.buyer_account().verify_link(¶ms).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/buyer-account/sign-in/link");
assert_eq!(seen[0].body_json(), json!({"token": "lnk_abc"}));
}
#[tokio::test]
async fn a_sign_in_from_a_keyless_client_sends_no_credential() {
let (_client, mock) = client_with(vec![Step::ok(
r#"{"methods":["code"],"expires_in_seconds":600}"#,
)]);
let keyless = crate::Delopay {
inner: std::sync::Arc::new(crate::http::client::Inner::with_transport(
mock.clone(),
"https://api.test".to_string(),
"https://checkout.test".to_string(),
String::new(),
0,
)),
};
keyless
.buyer_account()
.start_sign_in(&BuyerAccountSignInRequest::new("jane@example.com"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].header("api-key"), None);
assert_eq!(seen[0].header("authorization"), None);
}
#[tokio::test]
async fn get_session_sends_the_session_token_as_the_api_key() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"email":"j***@example.com","expires_at":1767225600,"has_password":false,
"surprise_field":1}"#,
)]);
let info = client.buyer_account().get_session().await.unwrap();
assert_eq!(info.expires_at, 1767225600);
assert_eq!(info.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-account/session");
assert_eq!(seen[0].header("api-key"), Some("prd_test"));
}
#[tokio::test]
async fn sign_out_deletes_the_session() {
let (client, mock) = client_with(vec![Step::ok(r#"{"deleted":true,"id":"x"}"#)]);
client.buyer_account().sign_out().await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(seen[0].url, "https://api.test/buyer-account/session");
}
#[tokio::test]
async fn sign_out_accepts_an_empty_body() {
let (client, _mock) = client_with(vec![Step::ok("")]);
client.buyer_account().sign_out().await.unwrap();
}
#[tokio::test]
async fn notice_settings_gets_the_settings() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"replies":true,"case_updates":false,"surprise_field":1}"#,
)]);
let out = client.buyer_account().notice_settings().await.unwrap();
assert!(out.replies);
assert!(!out.case_updates);
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/buyer-account/notice-settings"
);
}
#[tokio::test]
async fn set_notice_settings_puts_both_toggles() {
let (client, mock) =
client_with(vec![Step::ok(r#"{"replies":false,"case_updates":true}"#)]);
client
.buyer_account()
.set_notice_settings(&BuyerNoticeSettingsRequest::new(false, true))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/buyer-account/notice-settings"
);
assert_eq!(
seen[0].body_json(),
json!({"replies": false, "case_updates": true})
);
}
#[tokio::test]
async fn list_purchases_sends_every_query_parameter() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[{"id":"pay_1","record":"rec_1","kind":"payment","status":"succeeded",
"amount":1200,"currency":"EUR","created_at":"2026-01-01T00:00:00Z",
"shop":"pro_1","shop_name":"Shop","lines":[],"test_mode":false,
"confirmed":true,"confirmable":false}],
"next_cursor":"cur_2","surprise_field":1}"#,
)]);
let params = BuyerAccountPurchaseParams::new()
.limit(10)
.cursor("cur_1")
.shop("pro_1");
let page = client
.buyer_account()
.list_purchases(Some(¶ms))
.await
.unwrap();
assert_eq!(page.data[0].record, "rec_1");
assert_eq!(page.next_cursor.as_deref(), Some("cur_2"));
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-account/purchases?limit=10&cursor=cur_1&shop=pro_1"
);
}
#[tokio::test]
async fn list_shops_gets_the_shops_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[{"shop":"pro_1","name":"Shop"}],"surprise_field":1}"#,
)]);
let out = client.buyer_account().list_shops().await.unwrap();
assert_eq!(out.data[0].name, "Shop");
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/buyer-account/shops");
}
#[tokio::test]
async fn list_subscriptions_sends_the_section_query() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[{"id":"sub_1","record":"rec_1","shop":"pro_1","shop_name":"Shop",
"status":"active","created_at":"2026-01-01T00:00:00Z","test_mode":true,
"confirmed":false}],"has_more":false,"surprise_field":1}"#,
)]);
let params = BuyerAccountSectionParams::new()
.shop("pro_1")
.cursor("cur_1")
.limit(5)
.test_mode(true);
let out = client
.buyer_account()
.list_subscriptions(Some(¶ms))
.await
.unwrap();
assert!(!out.data[0].confirmed);
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/buyer-account/subscriptions?shop=pro_1&cursor=cur_1&limit=5&test_mode=true"
);
}
#[tokio::test]
async fn list_invoices_gets_the_invoices_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[{"id":"inv_1","record":"rec_1","shop":"pro_1","shop_name":"Shop",
"kind":"invoice","status":"issued","currency":"EUR","gross_amount":1190,
"supply_date":"2026-01-01","test_mode":false}],
"has_more":false,"unconfirmed_records":true,"surprise_field":1}"#,
)]);
let out = client
.buyer_account()
.list_invoices(Some(&BuyerAccountSectionParams::new().test_mode(false)))
.await
.unwrap();
assert_eq!(out.data[0].gross_amount, 1190);
assert!(out.unconfirmed_records);
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/buyer-account/invoices?test_mode=false"
);
}
#[tokio::test]
async fn list_refund_requests_gets_the_refund_requests_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[{"id":"rr_1","record":"rec_1","shop":"pro_1","shop_name":"Shop",
"purchase":"pay_1","purchase_kind":"payment","reason":"duplicate",
"message":"Charged twice","amount":500,"currency":"EUR","status":"approved",
"approved_amount":500,"created_at":"2026-01-01T00:00:00Z","test_mode":false}],
"has_more":false,"unconfirmed_records":false,"surprise_field":1}"#,
)]);
let out = client
.buyer_account()
.list_refund_requests(None)
.await
.unwrap();
assert_eq!(out.data[0].approved_amount, Some(500));
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/buyer-account/refund-requests"
);
}
#[tokio::test]
async fn list_cases_sends_the_shop_filter() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[],"has_more":false,"unconfirmed_records":true,"surprise_field":1}"#,
)]);
let out = client
.buyer_account()
.list_cases(Some("pro_1"))
.await
.unwrap();
assert!(out.unconfirmed_records);
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/buyer-account/cases?shop=pro_1"
);
}
#[tokio::test]
async fn list_conversations_without_a_shop_sends_no_query() {
let (client, mock) = client_with(vec![Step::ok(CONVERSATION_LIST_JSON)]);
let out = client
.buyer_account()
.list_conversations(None)
.await
.unwrap();
assert_eq!(out.data[0].record.as_deref(), Some("rec_1"));
assert_eq!(out.extra["surprise_field"], 2);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/buyer-account/conversations");
}
#[tokio::test]
async fn list_record_messages_encodes_the_record_and_sends_the_shop() {
let (client, mock) = client_with(vec![Step::ok(MESSAGE_PAGE_JSON)]);
let page = client
.buyer_account()
.list_record_messages("rec/1", &BuyerConversationParams::new("pro_1").limit(10))
.await
.unwrap();
assert_eq!(page.conversation.as_ref().unwrap().status, "closed");
assert_eq!(page.messages[0].sender_name.as_deref(), Some("Sam"));
assert_eq!(page.case_updates[0].event.actor, "provider");
assert_eq!(page.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-account/records/rec%2F1/messages?shop=pro_1&limit=10"
);
}
#[tokio::test]
async fn send_record_message_posts_to_the_record() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"id":"msg_2","sender":"buyer","body":"Thanks","attachments":[],
"created_at":"2026-01-01T00:00:00Z","surprise_field":1}"#,
)]);
let params = BuyerMessageCreateRequest::new("msg_12345678")
.shop("pro_1")
.test_mode(false)
.body("Thanks");
let out = client
.buyer_account()
.send_record_message("rec_1", ¶ms)
.await
.unwrap();
assert_eq!(out.id, "msg_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/buyer-account/records/rec_1/messages"
);
assert_eq!(
seen[0].body_json(),
json!({
"client_message_id": "msg_12345678",
"shop": "pro_1",
"test_mode": false,
"body": "Thanks"
})
);
assert!(!seen[0].had_idempotency_key());
}
#[tokio::test]
async fn mark_record_messages_read_posts_with_the_shop_query() {
let (client, mock) = client_with(vec![Step::ok(CONVERSATION_LIST_JSON)]);
client
.buyer_account()
.mark_record_messages_read("rec_1", &BuyerConversationParams::new("pro_1"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-account/records/rec_1/messages/read?shop=pro_1"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn upload_record_message_file_posts_multipart_with_the_shop() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"id":"att_1","file_name":"a.txt","file_type":"text","size_bytes":2,
"surprise_field":1}"#,
)]);
let upload = BuyerFileUpload::new("upl_12345678", "a.txt", "text/plain", b"hi");
let out = client
.buyer_account()
.upload_record_message_file("rec_1", &upload, &BuyerAttachmentParams::new("pro_1"))
.await
.unwrap();
assert_eq!(out.file_type, "text");
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-account/records/rec_1/messages/files?shop=pro_1"
);
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("filename=\"a.txt\"\r\nContent-Type: text/plain\r\n\r\nhi"));
}
#[tokio::test]
async fn download_record_message_file_gets_the_bytes() {
let (client, mock) = client_with(vec![Step::ok("hi")]);
let bytes = client
.buyer_account()
.download_record_message_file("rec_1", "att/1", &BuyerAttachmentParams::new("pro_1"))
.await
.unwrap();
assert_eq!(bytes, b"hi");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/buyer-account/records/rec_1/messages/files/att%2F1?shop=pro_1"
);
assert_eq!(seen[0].header("accept"), Some("*/*"));
}
#[tokio::test]
async fn remove_record_message_file_deletes_with_the_shop() {
let (client, mock) = client_with(vec![Step::ok(r#"{"deleted":true,"id":"x"}"#)]);
client
.buyer_account()
.remove_record_message_file(
"rec_1",
"att_1",
&BuyerAttachmentParams::new("pro_1").test_mode(true),
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/buyer-account/records/rec_1/messages/files/att_1?shop=pro_1&test_mode=true"
);
}
#[tokio::test]
async fn confirm_posts_the_portal_token() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"record":"rec_1","confirmed_at":1767225600,"surprise_field":1}"#,
)]);
let params = BuyerAccountConfirmRequest::new("ptk_secret");
assert!(!format!("{params:?}").contains("ptk_secret"));
let out = client.buyer_account().confirm(¶ms).await.unwrap();
assert_eq!(out.record, "rec_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/buyer-account/confirmations");
assert_eq!(seen[0].body_json(), json!({"portal_token": "ptk_secret"}));
}
#[tokio::test]
async fn open_portal_posts_to_the_record_and_redacts_the_url() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"url":"https://portal.example/s/ptk_secret","expires_at":1767225600,
"surprise_field":1}"#,
)]);
let portal = client.buyer_account().open_portal("rec/1").await.unwrap();
assert_eq!(portal.url, "https://portal.example/s/ptk_secret");
assert_eq!(portal.extra["surprise_field"], 1);
assert!(!format!("{portal:?}").contains("ptk_secret"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/buyer-account/records/rec%2F1/portal"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn case_evidence_encodes_record_and_case() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_JSON)]);
let out = client
.buyer_account()
.case_evidence("rec/1", "case/1")
.await
.unwrap();
assert_eq!(out.unavailable_reason.as_deref(), Some("case_closed"));
assert_eq!(out.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-account/records/rec%2F1/cases/case%2F1/evidence"
);
}
#[tokio::test]
async fn upload_evidence_file_posts_multipart_to_the_case() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_FILE_JSON)]);
let upload = BuyerFileUpload::new("upl_12345678", "photo.png", "image/png", b"PNG!");
let out = client
.buyer_account()
.upload_evidence_file("rec_1", "case_1", &upload)
.await
.unwrap();
assert_eq!(out.id, "file_1");
assert_eq!(out.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-account/records/rec_1/cases/case_1/evidence/files"
);
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!"));
}
#[tokio::test]
async fn download_evidence_file_gets_the_bytes() {
let (client, mock) = client_with(vec![Step::ok("PNG!")]);
let bytes = client
.buyer_account()
.download_evidence_file("rec_1", "case_1", "file_1")
.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-account/records/rec_1/cases/case_1/evidence/files/file_1"
);
}
#[tokio::test]
async fn remove_evidence_file_deletes_the_file() {
let (client, mock) = client_with(vec![Step::ok(r#"{"deleted":true,"id":"x"}"#)]);
client
.buyer_account()
.remove_evidence_file("rec_1", "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-account/records/rec_1/cases/case_1/evidence/files/file%2F1"
);
}
#[tokio::test]
async fn submit_evidence_posts_to_the_case() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_ENTRY_JSON)]);
let params = BuyerEvidenceSubmitRequest::new("sub_12345678").explanation("See photo");
client
.buyer_account()
.submit_evidence("rec_1", "case_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-account/records/rec_1/cases/case_1/evidence/submissions"
);
assert_eq!(
seen[0].body_json(),
json!({"client_submission_id": "sub_12345678", "explanation": "See photo"})
);
}
#[tokio::test]
async fn request_evidence_extension_posts_to_the_case() {
let (client, mock) = client_with(vec![Step::ok(EVIDENCE_ENTRY_JSON)]);
let out = client
.buyer_account()
.request_evidence_extension(
"rec_1",
"case_1",
&BuyerEvidenceExtensionRequest::new("Need a week"),
)
.await
.unwrap();
assert_eq!(out.kind, "extension_requested");
assert_eq!(out.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-account/records/rec_1/cases/case_1/evidence/extension-requests"
);
assert_eq!(seen[0].body_json(), json!({"message": "Need a week"}));
}
#[test]
fn buyer_account_sign_in_request_named_fields_are_complete() {
let req = BuyerAccountSignInRequest::new("a@example.com").locale("de");
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
BUYER_ACCOUNT_SIGN_IN_REQUEST_NAMED.contains(&key.as_str()),
"BUYER_ACCOUNT_SIGN_IN_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn buyer_account_verify_code_request_named_fields_are_complete() {
let req = BuyerAccountVerifyCodeRequest::new("a@example.com", "123456");
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
BUYER_ACCOUNT_VERIFY_CODE_REQUEST_NAMED.contains(&key.as_str()),
"BUYER_ACCOUNT_VERIFY_CODE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
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 account_writes_ignore_the_client_wide_idempotency_key() {
let (client, mock) = keyed_client(r#"{"methods":["code"],"expires_in_seconds":600}"#);
let params = BuyerAccountSignInRequest::new("buyer@example.com");
assert!(client.buyer_account().start_sign_in(¶ms).await.is_err());
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client(SESSION_JSON);
let params = BuyerAccountVerifyCodeRequest::new("buyer@example.com", "123456");
assert!(client.buyer_account().verify_code(¶ms).await.is_err());
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client(SESSION_JSON);
let params = BuyerAccountVerifyLinkRequest::new("lnk_abc");
assert!(client.buyer_account().verify_link(¶ms).await.is_err());
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client(r#"{"replies":true,"case_updates":true}"#);
assert!(
client
.buyer_account()
.set_notice_settings(&BuyerNoticeSettingsRequest::new(true, true))
.await
.is_err()
);
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client("");
assert!(client.buyer_account().sign_out().await.is_err());
assert_sent_once_without_key(&mock);
}
}